cm.h

基于h323协议的软phone

 * cmShutdown
 * purpose : This function should be called when all stack instances where destructed using
 *           cmEnd(), before shutting down the application.
 *           It should be called only if cmStartUp() was called.
 * input   : none
 * output  : none
 * return  : RV_OK on success, or a negative value on failure
 * notes   : cmShutdown() must be called from the same thread that called cmStartUp().
 ********************************************************************************************/
RVAPI
RvStatus RVCALLCONV cmShutdown(void);


/************************************************************************
 * cmInitialize
 * purpose: Initializes the Conference Manager instance.
 *          This function must be called before any other H.323 function
 *          except cmGetVersion().
 * input  : name    - Configuration file name to use
 * output : lphApp  - Application handle created for the initialized
 *                    stack instance
 * return : non-negative value on success
 *          negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmInitialize(IN char * name, OUT LPHAPP lphApp);

/************************************************************************
 * cmInit
 * purpose: Initializes the Conference Manager instance.
 *          This function must be called before any other H.323 function
 *          except cmGetVersion().
 * input  : name    - Configuration file name to use
 * output : none
 * return : Stack's application handle on success
 *          NULL on failure
 ************************************************************************/
RVAPI
HAPP RVCALLCONV cmInit(IN char * name);

/************************************************************************
 * cmEnd
 * purpose: Shuts down the Conference Manager instance and releases all
 *          resources that were in use by the Conference Manager instance.
 * input  : hApp    - Stack handle for the application
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 * notes  : cmEnd() must be called from the same thread that called cmInitialize().
 ************************************************************************/
RVAPI
int RVCALLCONV cmEnd(
        IN   HAPP        hApp);


/************************************************************************
 * cmStart
 * purpose: Starts the stack's activity
 *
 *          This function is only applicable when system.manualStart key
 *          is defined in the configuration. In manualStart mode cmInitialize()
 *          function does not automatically start Stack activity and accesses only
 *          the "system" configuration tree. To start the Stack use cmStart() function.
 *          The application may change configuration settings between cmInitialize()
 *          and cmStart() using cmGetXXXConfigurationHandle() functions.
 *
 * input  : hApp    - Stack handle for the application
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmStart(
        IN  HAPP        hApp);

/************************************************************************
 * cmStop
 * purpose: Stops the stack's activity
 *
 *          After the Stack is stopped by cmStop(), the application may change
 *          configuration settings and then use cmStart() to start Stack
 *          activity again.
 *
 * input  : hApp    - Stack handle for the application
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmStop(
        IN  HAPP        hApp);

/************************************************************************
 * cmRegister
 * purpose: Registers the endpoint with the gatekeeper.
 *          It is only applicable when the RAS.manualRAS key is not
 *          defined in the configuration (automatic RAS mode).
 *          It reads registration information from RAS.registrationInfo
 *          configuration key.
 * input  : hApp    - Application's handle of the stack
 * output : none
 * return : If an error occurs, the function returns a negative value.
 *          If no error occurs, the function returns a non-negative value.
 ************************************************************************/
RVAPI
int RVCALLCONV cmRegister(
        IN  HAPP        hApp);

/************************************************************************
 * cmUnregister
 * purpose: Unregisters the endpoint from the Gatekeeper
 *          It is only applicable when the RAS.manualRAS key is not
 *          defined in the configuration (automatic RAS mode).
 *          It reads registration information from RAS.registrationInfo
 *          configuration key.
 * input  : hApp    - Application's handle of the stack
 * output : none
 * return : If an error occurs, the function returns a negative value.
 *          If no error occurs, the function returns a non-negative value.
 ************************************************************************/
RVAPI
int RVCALLCONV cmUnregister(
        IN  HAPP        hApp);


/************************************************************************
 * cmGetRASConfigurationHandle
 * purpose: Gets the root Node ID of the RAS configuration tree.
 *          The application can then get and change configuration parameters
 *          for the control procedures.
 * input  : hApp     - Application's stack handle
 * output : none
 * return : The PVT Node ID of the RASConfiguration subtree on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
RvInt32 RVCALLCONV cmGetRASConfigurationHandle(
        IN  HAPP             hApp);



/************************************************************************
 * cmSendNonStandardMessage
 * purpose: Sends a nonstandard message to the Gatekeeper
 *          It is only applicable when the RAS.manualRAS key is not
 *          defined in the configuration (automatic RAS mode).
 *          It reads registration information from RAS.registrationInfo
 *          configuration key.
 * input  : hApp    - Application's handle of the stack
 *          nsParam - Nonstandard parameter to be used in non standard message
 * output : none
 * return : If an error occurs, the function returns a negative value.
 *          If no error occurs, the function returns a non-negative value.
 ************************************************************************/
RVAPI
int RVCALLCONV cmSendNonStandardMessage(
     IN      HAPP                hApp,
     IN      cmNonStandardParam* nsParam);

/************************************************************************
 * cmGetVersion
 * purpose: Returns the version of the Conference Manager in use.
 * input  : none
 * output : none
 * return : Pointer to the string representing the version of the
 *          Conference Manager. For example, "3.0.0.0" or "2.5".
 ************************************************************************/
RVAPI
char* RVCALLCONV cmGetVersion(void);

/************************************************************************
 * cmGetVersionName
 * purpose: Returns the version of the Conference Manager in use.
 * input  : buff    - Buffer to set the version in
 *          length  - Maximum length of the buffer in bytes
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmGetVersionName(
        IN    char*   buff,
        IN    int     length);


RVAPI
int RVCALLCONV
cmSetPreCallbackEvent(
        IN      HAPP                hApp,
        IN      cmNewCallbackEH     newCallback
        );

/************************************************************************
 * cmSetGenEventHandler
 * purpose: Installs the general event handler
 * input  : hApp    - Stack handle for the application
 *          cmEvent - Pointer to array of pointers to general event callback functions
 *          size    - Size of *cmEvent in bytes
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmSetGenEventHandler(
        IN      HAPP                hApp,
        IN      CMEVENT             cmEvent,
        IN      int                 size);

RVAPI
int RVCALLCONV cmGetGenEventHandler(
        IN      HAPP                hApp,
        IN      CMEVENT             cmEvent,
        IN      int                 size);


/************************************************************************
 * cmSetCallEventHandler
 * purpose: Installs the call event handler
 * input  : hApp        - Stack handle for the application
 *          cmCallEvent - Pointer to array of pointers to general event callback functions
 *          size        - Size of *cmCallEvent in bytes
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmSetCallEventHandler(
        IN      HAPP                hApp,
        IN      CMCALLEVENT         cmCallEvent,
        IN      int                 size);

RVAPI
int RVCALLCONV cmGetCallEventHandler(
        IN      HAPP                hApp,
        OUT     CMCALLEVENT         cmCallEvent,
        IN      int                 size);


/************************************************************************
 * cmCallNew
 * purpose: Creates a new call object that belongs to a particular Stack instance.
 *          This function does not launch any action on the network. It only causes
 *          the application and the Stack to exchange handles.
 * input  : hApp        - Stack handle for the application
 *          haCall      - Application's handle for the call
 * output : lphsCall    - Stack handle for the call to dial
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmCallNew(
        IN   HAPP        hApp,
        IN   HAPPCALL    haCall,
        OUT  LPHCALL     lphsCall);


/************************************************************************
 * cmCallDial
 * purpose: Dials a call. This function together with cmCallSetParam()
 *          can be used instead of cmCallMake(). cmCallSetParam() should
 *          be called before cmCallDial() and the required parameters of
 *          the call should be set
 * input  : hsCall      - Stack handle for the call to dial
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmCallDial(
        IN  HCALL       hsCall);


/************************************************************************
 * cmCallMake
 * purpose: Starts a new call setup with the given parameters
 * input  : hsCall      - Stack handle for the new call
 *          maxRate     - Maximum rate allowed for the new call
 *          minRate     - Minimum rate allowed for the new call.
 *                        This parameter is not currently in use, so set it to zero (0).
 *          destAddress - Called party address list
 *          srcAddress  - Calling party address list
 *          display     - String representing display information for reporting
 *                        to the called party
 *          userUser    - String representing user-to-user information for reporting
 *                        to the called party
 *          userUserSize- Length of the string representing user-to-user information
 *                        to report to the called party
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmCallMake(
        IN  HCALL       hsCall,
        IN  RvUint32    maxRate,
        IN  RvUint32    minRate,
        IN  char*       destAddress,
        IN  char*       srcAddress,
        IN  char*       display,
        IN  char*       userUser,
        IN  int         userUserSize);


RVAPI
int RVCALLCONV cmCallFacility(
           IN HCALL     hsCall,
           IN int       handle);

RVAPI
int RVCALLCONV cmSetCallHandle(
        IN HCALL                    hsCall,
        IN HAPPCALL                 haCall);


RVAPI
int RVCALLCONV cmCallGetDisplayInfo(
        IN  HCALL           hsCall,
        OUT char*           display,
        IN  int             displaySize);

RVAPI
int RVCALLCONV cmCallGetUserUserInfo(
        IN  HCALL           hsCall,
        OUT char*           userUser,
        IN  int             userUserSize);

RVAPI
int RVCALLCONV cmCallAnswerExt(
        IN  HCALL           hsCall,
                IN      char*               display,
                IN      char*               userUser,
                IN      int                 userUserSize);

RVAPI
int RVCALLCONV cmCallAnswerDisplay(
        IN  HCALL           hsCall,
                IN      char*               display);

/************************************************************************
 * cmCallAnswer
 * purpose: Answers an incoming call
 * input  : hsCall      - Stack handle for the call
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmCallAnswer(
        IN    HCALL       hsCall);