previous next

Interface List (continued)

IRMALiveFileFormatInfo

Purpose: Provides miscellaneous information needed to transmit a live stream.
Implemented by: File format plug-in
Used by: Information not yet available at publication.
Header file: rmalvpix.h

The IRMALiveFileFormatInfo interface contains the following methods:

As with all COM interfaces, the IRMALiveFileFormatInfo interface inherits the following IUnknown methods:

IRMALiveFileFormatInfo::FormResendPacket

Forms a live resend packet based on the original packet passed as the first parameter. This allows the file format plug-in to make resend packets distinguishable from original packets.


STDMETHOD(FormResendPacket) (
THIS_
IRMAPacket* pOriginalPacket,
REF(IRMAPacket*) pResendPacket
) PURE;
pOriginalPacket
Pointer to an IRMAPacket interface that manages the original packet.

pResendPacket
Returns a pointer to an IRMAPacket interface that manages the live resend packet.

IRMALiveFileFormatInfo::GetResendBitrate

Gets the rate at which packets should be resent if periodic live resends are required for this stream.


STDMETHOD(GetResendBitrate) (
THIS_
UINT16 unStreamNumber,
REF(UINT32) ulBitrate
) PURE;
unStreamNumber
The number of the stream.

ulBitrate
Returns the bitrate, in bits per second, at which packets should be resent.

IRMALiveFileFormatInfo::GetResendDuration

Gets the duration between the time a packet is sent and is then resent if periodic live resends are required for this stream.


STDMETHOD(GetResendDuration) (
THIS_
IRMAPacket* pPacket,
REF(UINT32) ulDuration
) PURE;
pPacket
Pointer to an IRMAPacket interface that manages the packet.

ulDuration
Returns the duration, in milliseconds, before this packet should be resent.

IRMALiveFileFormatInfo::IsLiveResendRequired

Returns TRUE if the indicated stream requires the latest packet to be resent periodically in a live presentation.


STDMETHOD_(BOOL,IsLiveResendRequired) (
THIS_
UINT16 unStreamNumber
) PURE;
unStreamNumber
The number of the stream.

IRMALiveFileFormatInfo::VerifyFileCompatibility

Compares two file headers and returns PNR_OK if these two files can be transmitted sequentially in a single live presentation.


STDMETHOD(VerifyFileCompatibility) (
THIS_
IRMAValues* pFileHeader1,
IRMAValues* pFileHeader2
) PURE;
pFileHeader1
Pointer to an IRMAValues interface that manages the header for the first file.

pFileHeader2
Pointer to an IRMAValues interface that manages the header for the second file.

IRMALiveFileFormatInfo::VerifyStreamCompatibility

Compares two stream headers and returns PNR_OK if these two streams can be transmitted sequentially in a single live presentation.


STDMETHOD(VerifyStreamCompatibility) (
THIS_
IRMAValues* pStreamHeader1,
IRMAValues* pStreamHeader2
) PURE;
pStreamHeader1
Pointer to an IRMAValues interface that manages the header for the first stream.

pStreamHeader2
Pointer to an IRMAValues interface that manages the header for the second stream.

IRMALiveRealPix

Purpose: Sends LiveRealPix data and mark-up to the LiveRealPix Broadcast Library
Implemented by: LiveRealPix Broadcast Library
Used by: LiveRealPix broadcast application
Header file: rmalvpix.h

This interface is used for live broadcasting of RealPix, as with successive jpeg images from a camera. A LiveRealPix broadcast application uses this interface to send LiveRealPix data and mark-up to the LiveRealPix Broadcast Library, which then broadcasts the images through RealServer.The response interface is IRMALiveRealPixResponse.

Additional Information
See "Chapter 18: RealPix Broadcast".

The IRMALiveRealPix interface contains the following methods:

As with all COM interfaces, the IRMALiveRealPix interface inherits the following IUnknown methods:

IRMALiveRealPix::GetTime

Returns the current time, in milliseconds, from the encoder.


STDMETHOD_(UINT32, GetTime) (
THIS
) PURE;

IRMALiveRealPix::InitImage

Prepares an image for being sent. This method simply breaks the image up into packets; nothing has yet been sent to the server. This is not an asynchronous call; all processing has finished by the time this call returns.


STDMETHOD(InitImage) (
THIS_
PixImageInfo *pImageInfo
) PURE;
pImageInfo
Pointer to a PixImageInfo structure that contains all the information for images that should be sent down the stream.

IRMALiveRealPix::Process

Gives the library time to send packets to the server. This method should be called very often in between IRMALiveRealPix::SendImage and IRMALiveRealPixResponse::ImageSent, as well as between IRMALiveRealPix::SendEffect and IRMALiveRealPixResponse::EffectSent. Other than these times, it should be called every three to five seconds.


STDMETHOD(Process) (
THIS
) PURE;

IRMALiveRealPix::SendEffect

Creates an effect packet and immediately adds this packet to the packet send queue. Further calls to IRMALiveRealPix::Process result in this packet being sent to the server. A handle is returned in the PixEffectInfo structure by which this effect can later be identified. When the effect has been sent to the server, the encoder responds with IRMALiveRealPixResponse::EffectSent.


STDMETHOD(SendEffect) (
THIS_
PixEffectInfo *pEffectInfo
) PURE;
pEffectInfo
Pointer to a PixEffectInfo structure that contains all the information about the effect that the RealPix renderer should perform.

IRMALiveRealPix::SendImage

Tranfers all the packets for the image into the packet send queue. Further calls to IRMALiveRealPix::Process result in these packets being sent to the server. When all the packets for this image have been sent, the encoder responds with IRMALiveRealPixResponse::ImageSent.


STDMETHOD(SendImage) (
THIS_
UINT32 ulImageHandle
) PURE;
ulImageHandle
The image handle for the packets being sent.

IRMALiveRealPix::StartEncoder

Starts the encoder. The encoder responds to this call asynchronously with IRMALiveRealPixResponse::EncoderStarted.


STDMETHOD(StartEncoder) (
THIS_
PixInitInfo *pInitInfo,
IRMALiveRealPixResponse *pResponse
) PURE;
pInitInfo
Pointer to a PixInitInfo structure that contains the initialization information.

pResponse
Pointer to an IRMALiveRealPixResponse interface that manages the response to various methods in this interface.

IRMALiveRealPix::StopEncoder

Informs the encoder that no more images of effects are going to be sent to the encoder. The encoder shuts down the connection to the server and responds with IRMALiveRealPixResponse::EncoderStopped. This method can be called at any time after calling IRMALiveRealPix::StartEncoder. Also, since the encoder can call back with IRMALiveRealPixResponse::EncoderStopped at any time, your application should be prepared to handle that situation.


STDMETHOD(StopEncoder) (
THIS
) PURE;

IRMALiveRealPixResponse

Purpose: Provides responses from IRMALiveRealPix
Implemented by: LiveRealPix Broadcast Library
Used by: LiveRealPix broadcast application
Header file: rmalvpix.h

This interface provides responses to many of the methods implemented by the IRMALiveRealPix interface.

Additional Information
See "Chapter 18: RealPix Broadcast".

The IRMALiveRealPixResponse interface contains the following methods:

As with all COM interfaces, the IRMALiveRealPixResponse interface inherits the following IUnknown methods:

IRMALiveRealPixResponse::EffectSent

Indicates whether the effect was sent successfully.


STDMETHOD(EffectSent) (
THIS_
PN_RESULT status,
UINT32 ulEffectHandle
) PURE;
status
Contains the response status to the IRMALiveRealPix::SendEffect operation. If this parameter is PNR_OK, the call completed successfully.

ulEffectHandle
Identifies which effect has just completed sending to the server. This is the handle that was set in the m_ulHandle member of the PixEffectInfo structure by IRMALiveRealPix::SendEffect.

IRMALiveRealPixResponse::EncoderStarted

Indicates whether the encoder started successfully.


STDMETHOD(EncoderStarted) (
THIS_
PN_RESULT status,
const char *pszHeaderString
) PURE;
status
Contains the response status to the IRMALiveRealPix::StartEncoder operation. If this parameter is PNR_OK, the call completed successfully.

pszHeaderString
Pointer to the text string returned by the server (for information only).

IRMALiveRealPixResponse::EncoderStopped

Indicates whether the encoder stopped successfully.


STDMETHOD(EncoderStopped) (
THIS_
PN_RESULT status
) PURE;
status
Contains the response status to the IRMALiveRealPix::StopEncoder operation. If this parameter is PNR_OK, the call completed successfully. At this point, the application can then shut down or call IRMALiveRealPix::StartEncoder again.

IRMALiveRealPixResponse::ErrorOccurred

Indicates the encoder has received an error from the server. Depending upon the severity of the error, the server might shut down the encoder and an IRMALiveRealPixResponse::EncoderStopped call would be made. Therefore, the application should be ready to handle an IRMALiveRealPixResponse::EncoderStopped call at any time. If an error occurs, you should call IRMALiveRealPix::StopEncoder and shut down the encoder from the application side.


STDMETHOD(ErrorOccurred) (
THIS_
const UINT8 unSeverity,
const ULONG32 ulRMACode,
const ULONG32 ulUserCode,
const char *pszUserString,
const char *pszMoreInfoURL
) PURE;
unSeverity
Severity of the error. This value impacts how the server reacts to the error. Depending on the error type, an error message with the RMA code and a string translation of that code is displayed. The error dialog includes a "more info" section that displays the user code and string, and a link to the more info URL. In the server these messages are logged to the log file. One of the following values:

ulRMACode
Well-known RMA error code. This is translated to a text representation for display in an error dialog box or log file.

ulUserCode
User-specific error code. This is not translated to a text representation. This can be any value the caller wants; it will be logged or displayed but not interpretted.

pUserString
Pointer to a user-specific error string. This is not translated or modified. This can be any value the caller wants; it will be logged or displayed but not interpretted.

pMoreInfoURL
Pointer to a user-specific more information URL string.

IRMALiveRealPixResponse::ImageSent

Indicates whether the send image operation completed successfully.


STDMETHOD(ImageSent) (
THIS_
PN_RESULT status,
UINT32 ulImageHandle
) PURE;
status
Contains the response status to the IRMALiveRealPix::SendImage operation. If this parameter is PNR_OK, the call completed successfully.

ulImageHandle
Identifies which image has just completed sending to the server.

IRMALiveText

Purpose: Sends RealText data and mark-up to the RealText Broadcast Library
Implemented by: RealText Broadcast Library
Used by: RealText broadcast application
Header file: rmalvtxt.h

This interface is used for live broadcasting of RealText, as with a live stock ticker feed. A RealText broadcast application uses this interface to send RealText data and mark-up to the RealText Broadcast Library, which then broadcasts the text through RealServer. There is no response interface.

Additional Information
See "Chapter 17: RealText Broadcast".

The IRMALiveText interface contains the following methods:

As with all COM interfaces, the IRMALiveText interface inherits the following IUnknown methods:

IRMALiveText::AddData

Adds text to the stream.


STDMETHOD(AddData) (
THIS_
char* szMoreData,
BOOL bSendImmediately
) PURE;
szMoreData
Pointer to the text to add to the stream. The text can include any RealText mark-up. If the text does not include <time begin> tags, the broadcast library timestamps the text as it is received. So if a broadcast application sends text string B to the library one second after it sends string A, the clients' RealText renderers display string B one second after displaying string A.

bSendImmediately
If TRUE, forces the encoder to send all text that has been added (and not yet sent) immediately. If FALSE, the encoder decides when to send the text it has buffered based on the length of the text in the buffer and the time since the last packet was sent.

IRMALiveText::AddTickerItem

Adds "tickertape" text to the stream. This method prepends "<TU>" to the characters in the szTickerUpperData parameter, and "<TL>" to the characters in the szTickerLowerData parameter. Therefore, calling AddTickerItem("ABCD", "5 1/2", TRUE) is the same as calling AddData("<TU>ABCD", FALSE) followed by AddData("<TL>5 1/2", TRUE), except that the former guarantees that the "upper" and "lower" items are sent in the same packet.


STDMETHOD(AddTickerItem) (
THIS_
char* szTickerUpperData,
char* szTickerLowerData,
BOOL bSendImmediately
) PURE;
szTickerUpperData
A NULL-terminated string that contains the text to be displayed in the upper line of the ticker tape.

szTickerLowerData
A NULL-terminated string that contains the text to be displayed in the lower line of the ticker tape.

bSendImmediately
If TRUE, forces the encoder to send all text that has been added (and not yet sent) immediately. If FALSE, the encoder decides when to send the text it has buffered based on the length of the text in the buffer and the time since the last packet was sent.

IRMALiveText::EncoderIsDone

Indicates whether the library has broadcast all the text it has received. A return value of TRUE indicates it has finished broadcasing all the text.


STDMETHOD_(BOOL,EncoderIsDone) (
THIS
) PURE;

IRMALiveText::EncoderIsInitialized

Indicates whether the library has received the initialization parameters that enable it to connect to the RealServer broadcast plug-in. After initialization, the library is ready to receive text. A return value of TRUE indicates the library has received the initialization parameters.


STDMETHOD_(BOOL,EncoderIsInitialized) (
THIS
) PURE;

IRMALiveText::flush

Tells the encoder to send everything that is in the buffer, then clear the buffer.


STDMETHOD(flush) (
THIS
) PURE;

IRMALiveText::GetTime

Returns the current system time in milliseconds.


STDMETHOD_(UINT32,GetTime) (
THIS
) PURE;

IRMALiveText::InitLiveText

Sets up the encoder so it can stream data through the server. The user name, password, and port are all values set up on the server (located at pAddress). This method must be called before any of the other IRMALiveText methods.


STDMETHOD(InitLiveText) (
THIS_
char* pAddress,
UINT16 port,
char* pUsername,
char* pPassword,
char* pFilename
) PURE;
pAddress
Pointer to the host name or IP address of the server.

port
The port number defined in the configuration file where the FSMount option has the following entry:

{ /encoder/, pn-encoder, Port=#### }

The value #### is the port number that encoders will use.

pUsername
Pointer to a NULL-terminated character buffer that contains the user name set up in the encoder realm of the server. This is the same user name used by RealAudio encoders.

pPassword
Pointer to a NULL-terminated character buffer that contains the password associated with the user name specified by pUsername. This is the same password used by RealAudio encoders.

pFilename
Pointer to the "file" name that clients use to view the stream. For example, if your server is called "srv1" and the RTSP port in the configuration file is 8080, and the filename from the encoder is "foo.rtx," then a client could view the stream by opening "rtsp://srv1:8080/encoder/foo.rtx".

IRMALiveText::PacketsHaveStarted

Indicates whether packets have started. A return value of TRUE indicates the packets have started.


STDMETHOD_(BOOL,PacketsHaveStarted) (
THIS
) PURE;

IRMALiveText::Process

Allows the library to perform necessary processing. This method should be called after calling IRMALiveText::AddData, IRMALiveText::AddTickerItem, or IRMALiveText::flush. When not sending text, the application should also call this method approximately every five seconds. This method is required due to the asynchronous nature of RealSystem.


STDMETHOD(Process) (
THIS
) PURE;

IRMALiveText::SetBackgroundColor

Controls the window's background color. If the application does not use this method, the property's default value is used.


STDMETHOD(SetBackgroundColor) (
THIS_
char* szBackgroundColor
) PURE;
szBackgroundColor
Pointer to the background color to be set. This background color can be any valid color string specified in the SMIL 1.0 specification. These color values are also listed in the RealText Authoring Guide at http://service.real.com/help/library/guides/realtext/realtext.htm.

IRMALiveText::SetDoLooping

Determines whether looping occurs. This method for "TickerTape"-type windows only; it is ignored by all other types. If the application does not use this method, the property's default value is used.


STDMETHOD(SetDoLooping) (
THIS_
BOOL bDoLooping
) PURE;
bDoLooping
If TRUE, looping will occur.

IRMALiveText::SetEncoderDone

Notifies the library that the application has finished sending text.


STDMETHOD(SetEncoderDone) (
THIS
) PURE;

IRMALiveText::SetHyperlinkInfo

Specifies whether hyperlinks are underlined and sets the hyperlink color. If the application does not use this method, the property's default value is used.


STDMETHOD(SetHyperlinkInfo) (
THIS_
BOOL underlineHyperlinks,
char* szLinkColor
) PURE;
underlineHyperlinks
If TRUE, the hyperlinks are underlined.

szLinkColor
Pointer to a NULL-terminated buffer that contains a color value for the hyperlink. This color can be any valid color string specified in the SMIL 1.0 specification. These color values are also listed in the RealText Authoring Guide at http://service.real.com/help/library/guides/realtext/realtext.htm.

IRMALiveText::SetTextMotion

Sets the window's scroll rate and crawl rate. If the application does not use this method, the property's default value is used.


STDMETHOD(SetTextMotion) (
THIS_
LONG32 scrollrate,
LONG32 crawlrate
) PURE;
scrollrate
The window's scroll rate (a value from 0 to 8192).

crawlrate
The window's crawl rate (a value from 0 to 8192).

IRMALiveText::SetType

Determines the window type (generic, tickertape, and so on). If the application does not use this method, the property's default value is used.


STDMETHOD(SetType) (
THIS_
char* szType
) PURE;
szType
Points to the window type. One of the following:

IRMALiveText::SetWindowDimensions

Controls the window's width and height. If the application does not use this method, the property's default value is used.


STDMETHOD(SetWindowDimensions) (
THIS_
ULONG32 width,
ULONG32 height
) PURE;
width
The width of the window, in pixels.

height
The height of the window, in pixels.

IRMALiveText::UseWordwrap

Sets word wrap on or off. If the application does not use this method, the property's default value is used.


STDMETHOD(UseWordwrap) (
THIS_
BOOL useWordwrap
) PURE;
useWordwrap
If TRUE, sets word wrap on.

IRMALiveText2

Purpose: Sends RealText data and mark-up to the RealText Broadcast Library
Implemented by: RealText Broadcast Library
Used by: RealText broadcast application
Header file: rmalvtxt.h

This interface is an addition to the IRMALiveText interface, which is used for live broadcasting of RealText, as with a live stock ticker feed. A RealText broadcast application uses this interface to send RealText data and mark-up to the RealText Broadcast Library, which then broadcasts the text through RealServer. There is no response interface.

The IRMALiveText2 interface contains the following methods:

As with all COM interfaces, the IRMALiveText2 interface inherits the following IUnknown methods:

IRMALiveText2::DeclareAverageBitrate

Gives an estimate of the bit rate needed by a live text stream so the server can determine whether or not a player can view the stream based on its available bandwidth. This method should be called before sending any data.


STDMETHOD(DeclareAverageBitrate) (
THIS_
ULONG32 ulAvgBitsPerSecond
) PURE;
ulAvgBitsPerSecond
The estimated bit rate, per second, needed by a live text stream.

IRMALiveText2::DeclareMaximumBitrate

Gives the maximum bit rate needed by a live text stream so that the server can determine whether or not a player can view the stream based on its available bandwidth. This method should be called before sending any data.


STDMETHOD(DeclareMaximumBitrate) (
THIS_
ULONG32 ulMaxBitsPerSecond
) PURE;
ulMaxBitsPerSecond
The maximum bit rate, per second, needed by a live text stream.

IRMALiveText2::GetLastSentTextEndTime

Tells when the last-sent text will end. This allows you to determine when it is all right to send more text. For example, if you are streaming a presentation that is scrolling at a rate of 20 pixels per second in a window that is 200 pixels high, and you call IRMALiveText::AddData with 100 lines of 20-point text, it will take 100 seconds for all that text to scroll up and out of the window. This method would return the current time plus 100 if you called it right after calling IRMALiveText::AddData.

This method can be called at any time while the encoder is running.


STDMETHOD(GetLastSentTextEndTime) (
THIS_
ULONG32& ulLastEndTime
) PURE;
ulLastEndTime
Address of the time when the last-sent text will end.

Note
If looping (see IRMALiveText::SetDoLooping) is set to TRUE in tickertape and marquee (and other windows with horizontal motion), then this method returns a value that is the start time of the last-added text. This is necessary because looping text has no defined end time.

IRMALiveText2::IgnoreExtraSpaces

Determines how multiple, contiguous space characters are presented. This method should be called before sending any data.


STDMETHOD(IgnoreExtraSpaces) (
THIS_
BOOL bIgnoreExtraSpaces
) PURE;
bIgnoreExtraSpaces
If FALSE (default), multiple spaces in non-tag text are rendered. If TRUE, multiple, contiguous spaces are treated as a single space.

IRMALiveText2::SetFlags

This method is for internal testing use only and does not affect the presentation of a live text stream.

IRMALiveText2::SetTimeBetweenDryStreamResends

Adjusts the time, since the last data was sent, that the encoder waits before resending "heartbeat" packets. These "heartbeat" packes let the server know the encoder still alive and to let newly-connected players know what is currently visible in the window, in case they connected during a "dry" period in the stream, after the last new text was sent.

This method can be called at any time while the encoder is running.


STDMETHOD(SetTimeBetweenDryStreamResends) (
THIS_
ULONG32 ulMillisecBetweenResends
) PURE;
ulMillisecBetweenResends
The number of milliseconds between resends. The minimum value for this parameter is 500 milliseconds. The default value for this parameter is 3000 milliseconds. Any higher value would result in longer connect times for players coming in during a "dry" spell in the stream. Any sufficiently higher value might cause the server to disconnect since it assumes the encoder has stopped if it does not periodically send data.

IRMALoadBalancedListen

Purpose: Requests a server to load balance multiple instances of the plug-in
Implemented by: Plug-ins
Used by: Information not yet available at publication.
Header file: rmaengin.h

The IRMALoadBalancedListen interface is queried off of IRMAListenSocket. This interface allows a plug-in to specify that it wants the server to load balance multiple instances of itself. The server will instantiate multiple instances of the plug-in as needed based on socket and descriptor limits. Each plug-in instance should attempt to listen on the same port as other instances (because they will share the port).

The IRMALoadBalancedListen interface contains the following methods:

As with all COM interfaces, the IRMALoadBalancedListen interface inherits the following IUnknown methods:

IRMALoadBalancedListen::SetID

Sets the unique ID for this listen socket. This ID determines whether or not different instances of a plug-in trying to listen on a single port are actually the same plug-in. Without this method, it would be possible for two completely different plug-ins to listen on the same port using the load balanced listener.


STDMETHOD(SetID) (
THIS_
REFIID ID
) PURE;
ID
The unique ID for this listen socket.

IRMALoadBalancedListen::SetReserveLimit

Sets the reserve limit for descriptors and sockets. If less than the reserve limit of descriptors and sockets are left, then a new instance of the plugin is created.


STDMETHOD(SetReserveLimit) (
THIS_
UINT32 ulDescriptors,
UINT32 ulSockets
) PURE;
ulDescriptors
The reserve limit for descriptors.

ulSockets
The reserve limit for sockets.

IRMAMultiInstanceSiteUserSupplier

Purpose: Attaches a Multi-Instance Site User Supplier (MISUS) object to a site
Implemented by: MISUS object (Client core)
Used by: Display rendering plug-in
Header file: rmawin.h

This is the interface to a MISUS object instantiated by the RealSystem client core. In normal RealSystem windowing, a display rendering plug-in that supports multiple sites renders data to this object, which in turn renders data to the multiple sites. The preferred implementation is to use IRMACommonClassFactory to create this interface.

Additional Information
See "Chapter 12: Sites (Windowing)". See also IRMASiteUserSupplier.

The IRMAMultiInstanceSiteUserSupplier interface contains the following methods:

As with all COM interfaces, the IRMAMultiInstanceSiteUserSupplier interface inherits the following IUnknown methods:

IRMAMultiInstanceSiteUserSupplier::ReleaseSingleSiteUser

Releases the renderer from the site.


STDMETHOD(ReleaseSingleSiteUser) (
THIS
) PURE;

IRMAMultiInstanceSiteUserSupplier::SetSingleSiteUser

Sets a single renderer that could be used for multiple sites.


STDMETHOD(SetSingleSiteUser) (
THIS_
IUnknown* pUnknown
) PURE;
pUnknown
Pointer to the IUnknown interface that identifies the instance of the MISUS object (IRMASiteUser).

IRMANetworkServices

Purpose: Creates networking objects
Implemented by: Network Services
Used by: Any component
Header file: rmaengin.h

RealSystem architecture's Network Services implements this interface, which any RealSystem component can use to generate network socket objects. Depending on the object type, the component can then use IRMAListenSocket, IRMAResolver, IRMATCPSocket, or IRMAUDPSocket. Broadcast and monitor plug-ins typically use this interface. For example, a broadcast plug-in uses Network Services to get a TCP socket to connect to its live source over a TCP/IP network.

Additional Information
See "Chapter 8: Broadcast Plug-in" or "Chapter 9: Monitor Plug-in".

The IRMANetworkServices interface contains the following methods:

As with all COM interfaces, the IRMANetworkServices interface inherits the following IUnknown methods:

IRMANetworkServices::CreateListenSocket

Creates a new TCP socket that listens for connections on a particular port.


STDMETHOD(CreateListenSocket) (
THIS_
IRMAListenSocket** ppListenSocket
) PURE;
ppListenSocket
Pointer to a pointer to an IRMAListenSocket interface that manages the new TCP socket.

IRMANetworkServices::CreateResolver

Creates a new resolver that can look up host names.


STDMETHOD(CreateResolver) (
THIS_
IRMAResolver** ppResolver
) PURE;
ppResolver
Pointer to a pointer to an IRMAResolver interface that resolves a DNS host name into an IP address.

IRMANetworkServices::CreateTCPSocket

Creates a new TCP socket.


STDMETHOD(CreateTCPSocket) (
THIS_
IRMATCPSocket** ppTCPSocket
) PURE;
ppTCPSocket
Pointer to pointer to an IRMATCPSocket interface that manages the new TCP socket.

IRMANetworkServices::CreateUDPSocket

Creates a new UDP socket.


STDMETHOD(CreateUDPSocket) (
THIS_
IRMAUDPSocket** ppUDPSocket
) PURE;
ppUDPSocket
Pointer to a pointer to an IRMAUDPSocket interface that manages the new UDP socket.

IRMAObjectConfiguration

Purpose: Initializing and configuring plug-ins
Implemented by: Plug-ins
Used by: Server core
Header file: rmaplgns.h

This interface contains alternate methods for initializing and configuring plug-ins. The IRMAObjectConfiguration::SetContext method can be use instead of IRMAPlugin::InitPlugin for setting the context of the plug-in. This is especially useful if you only need to set the configuration of the plug-in after the plug-in has been intialized, which can be accomplished using the IRMAObjectConfiguration::SetConfiguration method.

The IRMAObjectConfiguration interface contains the following methods:

As with all COM interfaces, the IRMAObjectConfiguration interface inherits the following IUnknown methods:

IRMAObjectConfiguration::SetConfiguration

Supplies configuration information from the plug-in. This configuration information is often a set of CString properties extracted from a list in the configuration file. This allows each plug-in within a specific class (that is, an authorization plug-in, a database plug-in, and so on) to require a different set of parameters. Typical configuration information handled by this method are realm, database ID, and so on. For example, this method might be used to configure an authentication object. The server core reads the server configuration file to determine the realm and database ID for authenticating a particular audio clip. If the clip's realm uses basic authentication, the server core will create an object that supports basic authentication. It will then call this method on that object os the object knows which realm and database ID to user for that clip.


STDMETHOD(SetConfiguration) (
THIS_
IRMAValues* pIRMAValuesConfiguration
) PURE;
pIRMAValuesConfiguration
Pointer to an IRMAValues interface that that manages the configuration information.

IRMAObjectConfiguration::SetContext

Passes in an object to a plug-in so the plug-in can use services from the server core. Both IRMAPlugin::InitPlugin and this method must be called before calling any other method on the plug-in. The server can use this method instead of IRMAPlugin::InitPlugin if the server does not need to assume that the object being dealt with is a plug-in.


STDMETHOD(SetContext) (
THIS_
IUnknown* pIUnknownContext
) PURE;
pIUnknownContext
Pointer to the IUnknown interface that identifies the instance of this object.

IRMAOptimizedScheduler

Purpose: Provides optimized scheduling of callbacks
Implemented by: RealSystem client
Used by: Rendering plug-in components
Header file: rmaengin.h

The IRMAOptimizedScheduler interface provides the user with a way of scheduling callbacks that will be executed at some time in the future. This interface should only be used if you need accurately-timed callbacks. These callbacks should be efficient and should not consume much time/CPU. This is not a thread-safe interface. The user must take care of synchronization in their callbacks.

The IRMAOptimizedScheduler interface contains the following methods:

As with all COM interfaces, the IRMAOptimizedScheduler interface inherits the following IUnknown methods:

IRMAOptimizedScheduler::AbsoluteEnter

Schedules a callback to be executed at a specified time. Returns a handle to the callback.


STDMETHOD_(CallbackHandle,AbsoluteEnter) (
THIS_
IRMACallback* pCallback,
RMATimeval tVal
) PURE;
pCallback
Pointer to an IRMACallback interface that manages the scheduled callback.

tVal
Pointer to an RMATimeval structure that specifies the time for the callback to be executed.

IRMAOptimizedScheduler::GetCurrentSchedulerTime

Returns a pointer to an RMATimeval structure that contains the current time in the timeline of the scheduler.


STDMETHOD_(RMATimeval,GetCurrentSchedulerTime) (
THIS
) PURE;

IRMAOptimizedScheduler::RelativeEnter

Schedules a callback to be executed a specified number of milliseconds from now. This method is less percise then IRMAOptimizedScheduler::AbsoluteEnter and should only be used when accurate timing is not critical. Returns the handle to the callback.


STDMETHOD_(CallbackHandle,RelativeEnter) (
THIS_
IRMACallback* pCallback,
UINT32 ms
) PURE;
pCallback
Pointer to an IRMACallback interface that manages the scheduled callback.

ms
The number of milliseconds before the callback is executed.

IRMAOptimizedScheduler::Remove

Removes a callback from the scheduler.


STDMETHOD(Remove) (
THIS_
CallbackHandle Handle
) PURE;
Handle
The handle to the callback to remove.

IRMAOptions

Purpose: Sets options on any component.
Implemented by: Any component
Used by: Any other component
Header file: rmavalue.h

If a component implements this interface, the caller can find out all of the options (and their types and current settings) by calling the IRMAOptions::GetOptions method. Then the caller can set any individual option by calling the appropriate IRMAOptions method, depending on the option type.

The IRMAOptions interface contains the following methods:

As with all COM interfaces, the IRMAOptions interface inherits the following IUnknown methods:

IRMAOptions::GetOptions

Returns a list of the options supported by this particular object, along with the value currently set for each option. Enumerate the members of the returned IRMAValues object to discover what options a component supports and the type of each of those options. The value for each name-value pair is the current setting for that option.


STDMETHOD(GetOptions) (
THIS_
REF(IRMAValues*) pOptions
) PURE;
pOptions
Returns a pointer to an IRMAValues interface that manages the list of options.

IRMAOptions::SetOptionBuffer

Sets the value of a buffer option.


STDMETHOD(SetOptionBuffer) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
pName
Pointer to the name of the option being set.

pValue
Pointer to an IRMABuffer interface that manages the buffer value of the option being set.

IRMAOptions::SetOptionCString

Sets the value of a CString option.


STDMETHOD(SetOptionCString) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
pName
Pointer to the name of the option being set.

pValue
Pointer to an IRMABuffer interface that manages the CString value of the option being set.

IRMAOptions::SetOptionULONG32

Sets the value of a ULONG32 option.


STDMETHOD(SetOptionULONG32) (
THIS_
const char* pName,
ULONG32 ulValue
) PURE;
pName
Pointer to the name of the option being set.

ulValue
The value of the option being set.

IRMAOverrideDefaultServices

Purpose: Overrides any default services provided by the G2 system.
Implemented by: RealSystem client
Used by: Plug-ins
Header file: rmaengin.h

This interface is queried off of the context. Currently, this interface is supported only on the client side. You can currently override IRMANetworkServices using this interface. You can use the same interface to later restore the overriden services by calling the IRMAOverrideDefaultServices::OverrideServices method with the original service that was queried (IUnknown::QueryInterface) before the initial override.

The IRMAOverrideDefaultServices interface contains the IRMAOverrideDefaultServices::OverrideServices method.

As with all COM interfaces, the IRMAOverrideDefaultServices interface inherits the following IUnknown methods:

IRMAOverrideDefaultServices::OverrideServices

Overrides the default services provided by the G2 system.


STDMETHOD(OverrideServices) (
THIS_
IUnknown* pContext
) PURE;
pContext
Pointer to the IUnknown interface that identifies the instance of the object for which services are being overridden.

IRMAPNRegistry

Purpose: Provides access to the RealServer registry
Implemented by: RealServer and RealSystem client
Used by: Monitor plug-ins
Header file: rmamon.h

The RealServer registry stores information about RealSystem events, such as how many clients are currently connected. A monitor plug-in can use the IRMAPNRegistry interface to gain access to this registry. This interface creates a registry object that the plug-in can then use to set watches on registry properties through IRMAPropWatch.

Additional Information
See "RealServer Property Registry".

The IRMAPNRegistry interface contains the following methods:

As with all COM interfaces, the IRMAPNRegistry interface inherits the following IUnknown methods:

IRMAPNRegistry::AddBuf

Adds a BUFFER property to the registry. This method returns the ID of the newly added property if successful or returns ZERO (0) if an error occurred during the operation.


STDMETHOD_(UINT32, AddBuf) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
pName
Pointer to the name of the newly added BUFFER property.

pValue
Pointer to an IRMABuffer interface that manages the BUFFER value.

IRMAPNRegistry::AddComp

Adds a COMPOSITE property to the registry. This method returns the ID of the newly added property if successful or returns ZERO (0) if an error occurred during the operation.


STDMETHOD_(UINT32, AddComp) (
THIS_
const char* pName
) PURE;
pName
Pointer to the name of the newly added COMPOSITE property.

IRMAPNRegistry::AddInt

Adds an INTEGER property to the registry. This method returns the ID of the newly-added property if successful or returns ZERO (0) if an error occurred during the operation.


STDMETHOD_(UINT32, AddInt) (
THIS_
const char* pName,
const INT32 iValue
) PURE;
pName
Pointer to the name of the newly-added INTEGER property.

iValue
The value of the newly added INTEGER property.

IRMAPNRegistry::AddIntRef

Adds an INTEGER REFERENCE property to the registry. This property lets the user modify its contents directly without having to go through the registry. This method returns the ID of the newly-added property if successful or returns ZERO (0) if an error occurred during the operation.


STDMETHOD_(UINT32, AddIntRef) (
THIS_
const char* pName,
INT32* pValue
) PURE;
pName
Pointer to the name of the newly-added INTEGER REFERENCE property.

pValue
Pointer to the value of the newly-added INTEGER REFERENCE property.

IRMAPNRegistry::AddStr

Adds a STRING property to the registry. This method returns the ID of the newly-added property if successful or returns ZERO (0) if an error occurred during the operation.


STDMETHOD_(UINT32, AddStr) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
pName
Pointer to the name of the newly-added STRING property.

pValue
Pointer to an IRMABuffer interface that manages the STRING value.

IRMAPNRegistry::CreatePropWatch

Creates a new IRMAPropWatch interface that can then be used to set watches on specific RealServer registry properties.


STDMETHOD(CreatePropWatch) (
THIS_
REF(IRMAPropWatch*) pPropWatch
) PURE;
pPropWatch
Returns a pointer to an IRMAPropWatch interface that manages the watches on RealServer registry properties.

IRMAPNRegistry::DeleteById

Deletes a property from the registry using its ID.


STDMETHOD_(UINT32, DeleteById) (
THIS_
const UINT32 ulID
) PURE;
ulID
The ID of the property to delete from the registry.

IRMAPNRegistry::DeleteByName

Deletes a property from the registry using its name.


STDMETHOD_(UINT32, DeleteByName) (
THIS_
const char* pcPropName
) PURE;
pcPropName
Pointer to the name of the property to delete from the registry.

IRMAPNRegistry::FindParentIdById

Returns the ID value of the parent node of the property whose ID has been specified. If this method fails, a ZERO value is returned.


STDMETHOD_(UINT32, FindParentIdById) (
THIS_
const UINT32 id
) const PURE;
id
The ID of the property from which to return the ID value of the parent node.

IRMAPNRegistry::FindParentIdByName

Returns the ID value of the parent node of the property whose name has been specified. If this method fails, a ZERO value is returned.


STDMETHOD_(UINT32, FindParentIdByName) (
THIS_
const char* pName
) const PURE;
pName
Pointer to the name of the property from which to return the ID value of the parent node.

IRMAPNRegistry::GetBufById

Retreives a BUFFER value from the registry given its property ID. If the property is found, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(GetBufById) (
THIS_
const UINT32 id,
REF(IRMABuffer*) ppValue
) const PURE;
id
The property ID of the BUFFER value to retrieve from the registry.

ppValue
Returns a pointer to an IRMABuffer interface that manages the BUFFER value.

IRMAPNRegistry::GetBufByName

Retreives a BUFFER value from the registry given its property name. If the property is found, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(GetBufByName) (
THIS_
const char* pName,
REF(IRMABuffer*) ppValue
) const PURE;
pName
Pointer to the property name of the BUFFER value to retrieve from the registry.

ppValue
Returns a pointer to an IRMABuffer interface that manages the BUFFER value.

IRMAPNRegistry::GetId

Returns the property's ID given the property name.


STDMETHOD_(UINT32, GetId) (
THIS_
const char* pName
) const PURE;
pName
Pointer to the property name from which to return the property ID.

IRMAPNRegistry::GetIntById

Retreives an INTEGER value from the registry given its property ID. If the property is found, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(GetIntById) (
THIS_
const UINT32 ulId,
REF(INT32) nValue
) const PURE;
ulID
The property ID of the INTEGER value to retrieve from the registry.

nValue
Returns the INTEGER value.

IRMAPNRegistry::GetIntByName

Retreives an INTEGER value from the registry given its property name. If the property is found, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(GetIntByName) (
THIS_
const char* pName,
REF(INT32) nValue
) const PURE;
pName
Pointer to the property name of the INTEGER value to retrieve from the registry.

nValue
Returns the INTEGER value.

IRMAPNRegistry::GetNumPropsAtRoot

Returns the number of properties at the root of the registry.


STDMETHOD_(INT32, GetNumPropsAtRoot) (
THIS
) const PURE;

IRMAPNRegistry::GetNumPropsById

Returns the count of the number of properties in the registry. If a property's ID is specified, then it returns the number of properties under that ID.


STDMETHOD_(INT32, GetNumPropsById) (
THIS_
const UINT32 id
) const PURE;
id
The property ID that specifies a starting point for the count.

IRMAPNRegistry::GetNumPropsByName

Returns the count of the number of properties in the registry. If a property name is specified, then it returns the number of properties under that name.


STDMETHOD_(INT32, GetNumPropsByName) (
THIS_
const char* pName
) const PURE;
pName
The property name that specifies a starting point for the count.

IRMAPNRegistry::GetPropListById

Returns an array of properties immediately under the one with the specified ID.


STDMETHOD(GetPropListById) (
THIS_
const UINT32 id,
REF(IRMAValues*) pValues
) const PURE;
id
The ID of the array of properties to return.

pValues
Returns a pointer to an IRMAValues interface that manages the array of properties.

IRMAPNRegistry::GetPropListByName

Returns an array of properties immediately under the one with the specified name.


STDMETHOD(GetPropListByName) (
THIS_
const char* pName,
REF(IRMAValues*) pValues
) const PURE;
pName
The name of the array of properties to return.

pValues
Returns a pointer to an IRMAValues interface that manages the array of properties.

IRMAPNRegistry::GetPropListOfRoot

Returns an array of properties under the root level of the registry's hierarchy.


STDMETHOD(GetPropListOfRoot) (
THIS_
REF(IRMAValues*) pValues
) const PURE;
pValues
Returns a pointer to an IRMAValues interface that manages the array of properties.

IRMAPNRegistry::GetPropName

Returns the property name given the property's ID.


STDMETHOD(GetPropName) (
THIS_
const UINT32 ulId,
REF(IRMABuffer*) pName
) const PURE;
ulID
The property ID of the property name to return.

pName
Returns a pointer to an IRMABuffer interface that manages the property name.

IRMAPNRegistry::GetStrById

Retreives a STRING value from the registry given its property ID. If the property is found, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(GetStrById) (
THIS_
const UINT32 id,
REF(IRMABuffer*) pValue
) const PURE;
id
The property ID of the STRING value to retrieve from the registry.

pValue
Returns a pointer to an IRMABuffer interface that manages the STRING value.

IRMAPNRegistry::GetStrByName

Retreives a STRING value from the registry given its property name. If the property is found, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(GetStrByName) (
THIS_
const char* pName,
REF(IRMABuffer*) pValue
) const PURE;
pName
Pointer to the property name of the STRING value to retrieve from the registry.

pValue
Returns a pointer to an IRMABuffer interface that manages the STRING value.

IRMAPNRegistry::GetTypeById

Returns the datatype of the property given its ID.


STDMETHOD_(RMAPropType, GetTypeById) (
THIS_
const UINT32 id
) const PURE;
id
The ID of the property from which to return the datatype.

IRMAPNRegistry::GetTypeByName

Returns the datatype of the property given its name.


STDMETHOD_(RMAPropType, GetTypeByName) (
THIS_
const char* pName
) const PURE;
pName
Pointer to the name of the property from which to return the datatype.

IRMAPNRegistry::SetBufById

Modifies a property's BUFFER value in the registry given its property ID. If the value was set, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(SetBufById) (
THIS_
const UINT32 id,
IRMABuffer* pValue
) PURE;
id
The property ID of the BUFFER value to set in the registry.

pValue
Pointer to an IRMABuffer interface that manages the new BUFFER value to be set.

IRMAPNRegistry::SetBufByName

Modifies a property's BUFFER value in the registry given its property name. If the value was set, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(SetBufByName) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
pName
Pointer to the property name of the BUFFER value to set in the registry.

pValue
Pointer to an IRMABuffer interface that manages the new BUFFER value to be set.

IRMAPNRegistry::SetIntById

Modifies a property's INTEGER value in the registry given its property ID. If the value was set, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(SetIntById) (
THIS_
const UINT32 id,
const INT32 iValue
) PURE;
id
The property ID of the INTEGER value to set in the registry.

iValue
The new INTEGER value to be set.

IRMAPNRegistry::SetIntByName

Modifies a property's INTEGER value in the registry given its property name. If the value was set, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(SetIntByName) (
THIS_
const char* pName,
const INT32 iValue
) PURE;
pName
Pointer to the property name of the INTEGER value to set in the registry.

iValue
The new INTEGER value to be set.

IRMAPNRegistry::SetStrById

Modifies a property's STRING value in the registry given its property ID. If the value was set, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(SetStrById) (
THIS_
const UINT32 id,
IRMABuffer* pValue
) PURE;
id
The property ID of the STRING value to set in the registry.

pValue
Pointer to an IRMABuffer interface that manages the new INTEGER value to be set.

IRMAPNRegistry::SetStrByName

Modifies a property's STRING value in the registry given its property name. If the value was set, this method returns PNR_OK, otherwise it returns PNR_FAIL.


STDMETHOD(SetStrByName) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
pName
Pointer to the property name of the STRING value to set in the registry.

pValue
Pointer to an IRMABuffer interface that manages the new INTEGER value to be set.

IRMAPPVDatabase

Purpose: Provides access to a pay-per-view database
Implemented by: Pay-per-view database plug-in
Used by: File system and pay-per-view allowance plug-ins
Header file: rmappv.h

This interface can be used to create a database plug-in to store pay-per-view data.

The IRMAPPVDatabase interface contains the following methods:

As with all COM interfaces, the IRMAPPVDatabase interface inherits the following IUnknown methods:

IRMAPPVDatabase::DeductTime

Deducts a user time to view. This method is obsolete and should not be used in any new applications.


STDMETHOD(DeductTime) (
THIS_
const char* pUserid,
const PPVPermission* pPPVPermission,
UINT32 ulDeduct
) PURE;
pUserid
Pointer to the user ID key of the record.

pPPVPermission
Pointer to a PPVPermission structure that contains the permission information and URL.

ulDeduct
The amount of time to deduct.

IRMAPPVDatabase::GetPasswordFromUserid

Gets a user's password.


STDMETHOD(GetPasswordFromUserid) (
THIS_
const char* pUserid,
char* pCipherPassword,
UINT32 ulCipherPasswordLen
) PURE;
pUserid
Pointer to the user ID key of the record.

pCipherPassword
Pointer to the password to retrieve.

ulCipherPasswordLen
The maximum length of the password in pCipherPassword.

IRMAPPVDatabase::GetPPVDBInfo

Gets this database's short name. This unique identifier identifies this database plug-in, and should be unique enough that no other plug-in will ever have the same plug-in name.


STDMETHOD(GetPPVDBInfo) (
THIS_
REF(const char*) pShortName
) PURE;
pShortName
Returns a pointer to the short name of the database.

IRMAPPVDatabase::GetRedirect

Gets the redirection URL corresponding to the requested URL from the database.


STDMETHOD(GetRedirect) (
THIS_
const char* pURL,
char* pURLRedirect,
UINT32 ulURLRedirectLen
) PURE;
pURL
Pointer to the URL key for the record to redirect.

pURLRedirect
Pointer to the URL to which to redirect.

ulURLRedirectLen
The maximum length of the URL in pURLRedirect.

IRMAPPVDatabase::GetUseridFromGUID

Gets a user's ID. For this method to return a valid user ID, GUID logging must be enabled (that is, the GUID cannot be all zeroes).


STDMETHOD(GetUseridFromGUID) (
THIS_
const char* pGUID,
char* pUserid,
UINT32 ulUseridLen
) PURE;
pGUID
Pointer to the GUID of an existing user. This GUID may be all zeroes if GUID logging has been disabled by the client or the server.

pUserid
Pointer to the user ID key to retrieve.

ulUseridLen
The maximum length of the user ID key in pUserid.

IRMAPPVDatabase::GrantPermission

Adds a permission record.


STDMETHOD(GrantPermission) (
THIS_
const char* pUserid,
const PPVPermission* pPPVPermission
) PURE;
pUserid
Pointer to the user ID key of the record.

pPPVPermission
Pointer to a PPVPermission structure that contains the permission information and URL.

IRMAPPVDatabase::GrantTime

Grants a user time to view. This method is obsolete and should not be used by any new applications.


STDMETHOD(GrantTime) (
THIS_
const char* pUserid,
const PPVPermission* pPPVPermission,
UINT32 ulGrant
) PURE;
pUserid
Pointer to the user ID key of the record.

pPPVPermission
Pointer to a PPVPermission structure that contains the permission information and URL.

ulGrant
The amount of time to grant.

IRMAPPVDatabase::InitPPVDB

Opens and initializes the pay-per-view database. This method is called once per instance before any other methods in this interface are called.


STDMETHOD(InitPPVDB) (
THIS_
const char* pDBName,
const char* pUserID,
const char* pPassword
) PURE;
pDBName
Pointer to the name of the database (if supported).

pUserID
Pointer to the user ID used to access the database (if supported).

pPassword
Pointer to the password used to access the database (if supported).

IRMAPPVDatabase::InsertUser

Inserts a user in the database (the user should not already exist).


STDMETHOD(InsertUser) (
THIS_
const char* pUserid,
const char* pPasswordCipher
) PURE;
pUserid
Pointer to the user ID key of the record to insert.

pPasswordCipher
Pointer to an optional password to associate with this user. The password being passed in is already encrypted.

IRMAPPVDatabase::LogAccess

Inserts a new record into the user authentication database.


STDMETHOD(LogAccess) (
THIS_
PPVAccessLog* pPPVAccessLog
) PURE;
pPPVAccessLog
Pointer to a PPVAccessLog structure that contains the logging information.

Additional Information
See the chapters on authenticating RealServer visitors and storing authentication data in the RealServer G2 Administration Guide for information on user authentication.

IRMAPPVDatabase::LogReg

Inserts a new record into the database. This method uses information supplied by the IRMAPPVDatabase::RegisterGUID method.


STDMETHOD(LogReg) (
THIS_
PPVRegLog* pPPVRegLog
) PURE;
pPPVRegLog
Pointer to a PPVRegLog structure that contains the logging information.

Additional Information
See the chapters on authenticating RealServer visitors and storing authentication data in the RealServer G2 Administration Guide for information on player validation.

IRMAPPVDatabase::PutRedirect

Adds a redirection URL to the database that corresponds with the URL key.


STDMETHOD(PutRedirect) (
THIS_
const char* pURL,
const char* pURLRedirect
) PURE;
pURL
Pointer to the URL key.

pURLRedirect
Pointer to the redirection URL to be added to the database.

IRMAPPVDatabase::RegisterGUID

Registers a GUID to be associated with the given user ID. For the GUID to be properly associated with the user ID, GUID logging must be enabled (that is, the GUID cannot be all zeroes).


STDMETHOD(RegisterGUID) (
THIS_
const char* pUserid,
const char* pGUID,
BOOL bForce
) PURE;
pUserid
Pointer to the user ID key of the record.

pGUID
Pointer to the GUID to associate with the user record.

bForce
If TRUE, forces the registration of the GUID, even if the uuid_writeable flag in the server's authentication database is set to read only. See the chapter on storing authentication data in the RealServer Administration Guide for more information on uuid_writeable.

IRMAPPVDatabase::RemoveUser

Removes a user from the database.


STDMETHOD(RemoveUser) (
THIS_
const char* pUserid
) PURE;
pUserid
Pointer to the user ID key of the record.

IRMAPPVDatabase::RevokeAllPermissions

Removes all permission records for a user.


STDMETHOD(RevokeAllPermissions) (
THIS_
const char* pUserid
) PURE;
pUserid
Pointer to the user ID key of the record.

IRMAPPVDatabase::RevokePermission

Removes a permission record.


STDMETHOD(RevokePermission) (
THIS_
const char* pUserid,
const PPVPermission* pPPVPermission
) PURE;
pUserid
Pointer to the user ID key of the record.

pPPVPermission
Pointer to a PPVPermission structure that contains the permission information and URL.

IRMAPPVDatabase::SetPassword

Sets the password for the user associated with the given user ID.


STDMETHOD(SetPassword) (
THIS_
const char* pUserid,
const char* pCipherPassword
) PURE;
pUserid
Pointer to the user ID key of the record.

pCipherPassword
Pointer to the user's password.

IRMAPPVDatabase::ValidateUser

Validates whether the user associated with the given user ID should be given permission to view a specific piece of content. If the user is granted permission to view the file, the database should fill in the other members of the PPVPermission structure with information about what kind of permission the user should be granted (that is, should the user be granted a number of seconds of viewing time, or should they be able to watch until a specific expiration date, and so on).


STDMETHOD(ValidateUser) (
THIS_
const char* pUserid,
PPVPermission* pPPVPermission
) PURE;
pUserId
Pointer to the user ID key of the record.

pPPVPermission
Pointer to a PPVPermission structure that contains the URL of the content that requires validation.

IRMAPPVDBManager

Purpose: Provides storage of pay-per-view permission data
Implemented by: Database plug-in
Used by: File system and pay-per-view allowance plug-ins
Header file: rmadb.h

This interface administers and enforces permissions for pay-per-view content. The response interface is IRMAPPVDBManagerResponse.

The IRMAPPVDBManager interface contains the following methods:

As with all COM interfaces, the IRMAPPVDBManager interface inherits the following IUnknown methods:

IRMAPPVDBManager::GetPermissions

Retrieves the pay-per-view permissions for the specified URL and user.


STDMETHOD(GetPermissions) (
THIS_
IRMAPPVDBManagerResponse* pPPVDBManagerResponseNew,
IRMABuffer* pBufferPrincipalID,
IRMABuffer* pBufferURL
) PURE;
pPPVDBManagerResponseNew
Pointer to an IRMAPPVDBManagerResponse interface that manages the response to this method.

pBufferPrincipalID
Pointer to an IRMABuffer interface that manages the specified user's identification.

pBufferURL
Pointer to an IRMABuffer interface that manages the specified URL.

IRMAPPVDBManager::LogAccessAttempt

Records the results of an attempt to access protected content.


STDMETHOD(LogAccessAttempt) (
THIS_
IRMAValues* pValuesAccess
) PURE;
pValuesAccess
Pointer to an IRMAValues interface that manages the result of an attempt to access protected content. The following keys are used:

IRMAPPVDBManager::RevokeAllPermissions

Removes the pay-per-view permissions for all URLs to which this user has access.


STDMETHOD(RevokeAllPermissions) (
THIS_
IRMAPPVDBManagerResponse* pPPVDBManagerResponseNew,
IRMABuffer* pBufferPrincipalID
) PURE;
pPPVDBManagerResponseNew
Pointer to an IRMAPPVDBManagerResponse interface that manages the response to this method.

pBufferPrincipalID
Pointer to an IRMABuffer interface that manages the specified user's identification.

IRMAPPVDBManager::RevokePermissions

Removes the pay-per-view permissions for the specified URL and user.


STDMETHOD(RevokePermissions) (
THIS_
IRMAPPVDBManagerResponse* pPPVDBManagerResponseNew,
IRMABuffer* pBufferPrincipalID,
IRMABuffer* pBufferURL
) PURE;
pPPVDBManagerResponseNew
Pointer to an IRMAPPVDBManagerResponse interface that manages the reponse to this method.

pBufferPrincipalID
Pointer to an IRMABuffer interface that manages the specified user's identification.

pBufferURL
Pointer to an IRMABuffer interface that manages the specified URL.

IRMAPPVDBManager::SetPermissions

Sets the pay-per-view permissions for the specified URL and user.


STDMETHOD(SetPermissions) (
THIS_
IRMAPPVDBManagerResponse* pPPVDBManagerResponseNew,
IRMABuffer* pBufferPrincipalID,
IRMABuffer* pBufferURL,
IRMAValues* pValuesPermissions
) PURE;
pPPVDBManagerResponseNew
Pointer to an IRMAPPVDBManagerResponse interface that manages the response to this method.

pBufferPrincipalID
Pointer to an IRMABuffer interface that manages the specified user's identification.

pBufferURL
Pointer to an IRMABuffer interface that manages the specified URL.

pValuesPermissions
Pointer to an IRMAValues interface that manages the pay-per-view permissions. The following keys are used:

IRMAPPVDBManagerResponse

Purpose: Manages pay-per-view permission data
Implemented by: Database user
Used by: Database plug-in
Header file: rmadb.h

This interface provide an asynchronous response to IRMAPPVDBManager.

The IRMAPPVDBManagerResponse interface contains the following methods:

As with all COM interfaces, the IRMAPPVDBManagerResponse interface inherits the following IUnknown methods:

IRMAPPVDBManagerResponse::GetPermissionsDone

Reports the status of the call to get the pay-per-view permissions, and returns the permissions for the specifed user.


STDMETHOD(GetPermissionsDone) (
THIS_
PN_RESULT ResultStatus,
IRMABuffer* pBufferPrincipalID,
IRMAValues* pValuesPermissions
) PURE;
ResultStatus
The status of the IRMAPPVDBManager::GetPermissions operation. A value of PNR_OK indicates the operation has completed successfully.

pBufferPrincipalID
Pointer to an IRMABuffer interface that manages the user's identification.

pValuesPermissions
Pointer to an IRMAValues interface that manages the pay-per-view permissions. The following keys are used:

IRMAPPVDBManagerResponse::RevokeAllPermissionsDone

Reports the status of the call to revoke all the pay-per-view permissions for the specified user.


STDMETHOD(RevokeAllPermissionsDone) (
THIS_
PN_RESULT ResultStatus,
IRMABuffer* pBufferPrincipalID
) PURE;
ResultStatus
The status of the IRMAPPVDBManager::RevokeAllPermissions operation. A value of PNR_OK indicates the operation has completed successfully.

pBufferPrincipalID
Pointer to an IRMABuffer interface that manages the user's identification.

IRMAPPVDBManagerResponse::RevokePermissionsDone

Reports the status of the call to revoke the pay-per-view permissions for the specified user.


STDMETHOD(RevokePermissionsDone) (
THIS_
PN_RESULT ResultStatus,
IRMABuffer* pBufferPrincipalID
) PURE;
ResultStatus
The status of the IRMAPPVDBManager::RevokePermissions operation. A value of PNR_OK indicates the operation has completed successfully.

pBufferPrincipalID
Pointer to an IRMABuffer interface that manages the user's identification.

IRMAPPVDBManagerResponse::SetPermissionsDone

Reports the status of the call to set the pay-per-view permissions for the specified user.


STDMETHOD(SetPermissionsDone) (
THIS_
PN_RESULT ResultStatus,
IRMABuffer* pBufferPrincipalID
) PURE;
ResultStatus
The status of the IRMAPPVDBManager::SetPermissions operation. A value of PNR_OK indicates the operation has completed successfully.

pBufferPrincipalID
Pointer to an IRMABuffer interface that manages the user's identification.


Copyright © 2000 RealNetworks
For technical support, please contact supportsdk@real.com.
This file last updated on 05/17/00 at 12:50:34.
previous next