rvmdmpkg.c

h.248协议源码

/******************************************************************************
Filename   : rvmdmpkg.c
Description: Package,event and signal information for Media Device Manager
******************************************************************************
                Copyright (c) 1999 RADVision Inc.
************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision LTD.
No part of this publication may be reproduced in any form whatsoever 
without written prior approval by RADVision LTD..

RADVision LTD. reserves the right to revise this publication and make 
changes without obligation to notify any person of such revisions or 
changes.
******************************************************************************
$Revision:$
$Date:1.9.01$
$Author: D.Elbert$
******************************************************************************/
#include "rvalloc.h"
#include "rvmap.h"
#include "rvmegacoobjects.h"
#include "rvmdmpkg.h"
#include "rvmdm.h"
#include "rvstr.h"

rvDefineMap(RvIString, RvMdmEventInfo)
rvDefineMap(RvIString, RvMdmSignalInfo)


/***********************************************************************************/
/*		Methods for package registration                                           */
/***********************************************************************************/
/* Get digitmap package info or NULL */
RvMdmDigitMapData* rvMdmTermMgrGetDigitMapPkgInfo_(RvMdmTermMgr * mgr,const char * pkg) {
	RvPtrListIter i;
	RvMdmDigitMapData * data;

	for(i=rvPtrListBegin(&mgr->digitMapData);i!=rvPtrListEnd(&mgr->digitMapData);i=rvPtrListIterNext(i)) {
		data = (RvMdmDigitMapData *)rvPtrListIterData(i);
		if(!rvStrIcmp(pkg,rvMegacoPackageItemGetPackage(&data->pkgItem)))
			return data;
	}
	return NULL;
}

void rvMdmTermMgrSetDigitMapPkgInfo_(RvMdmTermMgr * mgr,RvMdmDigitMapData * dmData) {
	RvMdmDigitMapData * newDigitMap = rvAllocAllocate(mgr->a,sizeof(RvMdmDigitMapData));
	rvMdmDigitMapDataCopyConstruct(newDigitMap,dmData,mgr->a);
	rvPtrListPushBack(&mgr->digitMapData,newDigitMap);
}

/*------------------------------------------------------------------------------*/
/* RvMdmEventData methods                                                       */
/*------------------------------------------------------------------------------*/

/*$
{function:
	{name: rvMdmEventDataConstruct}
	{class: RvMdmEventData}
	{include: rvmdm.h}
	{description:
		{p: Construct an EventData object to register with an RvMdmPackage.}
	}
	{proto: void rvMdmEventDataConstruct(RvMdmEventData* x,const char* id);}
	{params:
		{param: {n:x} {d:The object.}}
		{param: {n:id} {d:The event id.}}
	}
}
$*/
void rvMdmEventDataConstruct(RvMdmEventData* x,const char* id) {
	rvMdmEventDataConstructA(x,id,&rvDefaultAlloc);
}

void rvMdmEventDataConstructA(RvMdmEventData* x,const char* id,RvAlloc* a) {
	rvStringConstruct(&x->id,id,a);
	rvMegacoParameterListConstructA(&x->args,a);
/*	x->paramF = NULL; */
/*	x->enableF = NULL;*/
}

/*$
{function:
	{name: rvMdmEventDataDestruct}
	{class: RvMdmEventData}
	{include: rvmdm.h}
	{description:
		{p: Destruct an EventData object.}
	}
	{proto: void rvMdmEventDataDestruct(RvMdmEventData* x);}
	{params:
		{param: {n:x} {d:The object.}}
	}
}
$*/
void rvMdmEventDataDestruct(RvMdmEventData* x) {
	rvStringDestruct(&x->id);
	rvMegacoParameterListDestruct(&x->args);
}

/*$
{function:
	{name: rvMdmEventDataAddParameter}
	{class: RvMdmEventData}
	{include: rvmdm.h}
	{description:
  		{p: Register a parameter associated a requested event.}
		{p: The MGC set this parameters to customize the generated events.}
		{p: Set the value or values that the MG can accept for each parameter, 
			and a callback function to be called to process it.}
	}
	{proto: void rvMdmEventDataAddParameter(RvMdmEventData* x,const char* name, 
								const RvMegacoParameterValue* value,
								RvMdmEventParamCB func);}
	{params:
		{param: {n:x} {d:The object.}}
		{param: {n:name} {d:The parameter name.}}
		{param: {n:value} {d:The parameter possible values (single,range or list).}}
	}
	{notes:
		{note: 
			MEGACO: Call only for events which define EventDescriptor parameters.
		}
	}
}
$*/
void rvMdmEventDataAddParameter(RvMdmEventData* x,const char* name, 
								const RvMegacoParameterValue* value,
								RvMdmEventParamCB func) {
	rvMegacoParameterListSet2(&x->args,name,value);
}

/*------------------------------------------------------------------------------*/
/* RvMdmSignalData methods                                                      */
/*------------------------------------------------------------------------------*/
/*$
{function:
	{name: rvMdmSignalDataConstruct}
	{class: RvMdmSignalData}
	{include: rvmdm.h}
	{description:
		{p: Construct a SignalData object to register with an RvMdmPackage.}
	}
	{proto: void rvMdmSignalDataConstruct(RvMdmSignalData* x,const char* id,RvMegacoSignalType type);}
	{params:
		{param: {n:x} {d:The object.}}
		{param: {n:id} {d:The signal id.}}
		{param: {n:type} {d:The signal type.}}
	}
}
$*/
void rvMdmSignalDataConstruct(RvMdmSignalData* x,const char* id,RvMegacoSignalType type){
	rvMdmSignalDataConstructA(x,id,type,&rvDefaultAlloc);
}

void rvMdmSignalDataConstructA(RvMdmSignalData* x,const char* id,RvMegacoSignalType type,RvAlloc* a){
	rvStringConstruct(&x->id,id,a);
	rvMegacoParameterListConstructA(&x->args,a);
	x->type = type;
	x->timeout = 0;
}

/*$
{function:
	{name: rvMdmSignalDataDestruct}
	{class: RvMdmSignalData}
	{include: rvmdm.h}
	{description:
		{p: Destruct a SignalData object.}
	}
	{proto: void rvMdmSignalDataDestruct(RvMdmSignalData* x);}
	{params:
		{param: {n:x} {d:The object.}}
	}
}
$*/
void rvMdmSignalDataDestruct(RvMdmSignalData* x){
	rvStringDestruct(&x->id);
	rvMegacoParameterListDestruct(&x->args);
}
/*$
{function:
	{name: rvMdmSignalDataSetTimeout}
	{class: RvMdmSignalData}
	{include: rvmdm.h}
	{description:
		{p: Set signal timeout value (for signals of type RV_MEGACOSIGNAL_TIMEOUT).}
	}
	{proto: void rvMdmSignalDataSetTimeout(RvMdmSignalData* x,RvMilliseconds timeout)}
	{params:
		{param: {n:x} {d:The signal data object.}}
		{param: {n:timeout} {d:The timeout value in miliseconds.}}
	}
}
$*/
void rvMdmSignalDataSetTimeout(RvMdmSignalData* x,RvMilliseconds timeout){
	x->timeout = timeout;
}

/*$
{function:
	{name: rvMdmSignalDataAddParameter}
	{class: RvMdmSignalData}
	{include: rvmdm.h}
	{description:
		{p: Register a parameter associated with the signal and the value or values that can accept.}
	}	
	{proto: void rvMdmSignalDataAddParameter(RvMdmSignalData* x,const char* name,const RvMegacoParameterValue* value);}
	{params:
		{param: {n:x} {d:The object.}}
		{param: {n:name} {d:The parameter name.}}
		{param: {n:value} {d:The parameter possible values (single,range or list).}}
	}
	{notes:
		{note: 
			Call only for Signals which define parameters.
		}
	}
}
$*/
void rvMdmSignalDataAddParameter(RvMdmSignalData* x,const char* name, const RvMegacoParameterValue* value){
	rvMegacoParameterListSet2(&x->args,name,value);
}

/*------------------------------------------------------------------------------*/
/* RvMdmDigitMapData methods                                                    */
/*------------------------------------------------------------------------------*/

/*$
{function:
	{name: rvMdmDigitMapDataConstruct}
	{class: RvMdmDigitMapData}
	{include: rvmdm.h}
	{description:
		{p: Constructs an RvMdmDigitMapData object, which defines package specific handling of digitmap events.}
	}	
	{proto: void rvMdmDigitMapDataConstruct(RvMdmDigitMapData* dmData,
											const char* completionEventName,
											RvMdmDigitMapBuildCompletionEvCB completeEvF,
											RvMdmDigitMapTranslateEventCB    translateF,
											void* userData);}
	{params:
		{param: {n:dmData} {d:The object.}}
		{param: {n:completionEventName} {d:The name of the digitmap completion event for the package.}}
		{param: {n:completeEvF} {d:This callback will be called by the Media Device Manager when it generates 
								   a digitMap completion event.}} 
		{param: {n:translateF} {d:This callback translates (maps) the events of the package to valid digitmap 
								  symbols (0-9, A-F). }} 
		{param: {n:userData} {d:Will be a parameter to completeEvF.}}
	}
	{notes:
		{note: 
			Only for packages which support digitmap events (MEGACO: dd).
		}
	}
}
$*/
void rvMdmDigitMapDataConstruct(RvMdmDigitMapData* dmData,
								const char* completionEventName,
								RvMdmDigitMapBuildCompletionEvCB completeEvF,
								RvMdmDigitMapTranslateEventCB  translateF,
								void * userData) {
	rvMdmDigitMapDataConstructA(dmData,completionEventName,
								completeEvF,translateF,userData,
								&rvDefaultAlloc);
							    
}

void rvMdmDigitMapDataConstructA(RvMdmDigitMapData* dmData,
								 const char* completionEventName,
								 RvMdmDigitMapBuildCompletionEvCB completeEvF,
								 RvMdmDigitMapTranslateEventCB  translateF,
								 void* userData,
								 RvAlloc * alloc){
	rvMegacoPackageItemConstructA(&dmData->pkgItem,"",completionEventName,alloc);
	dmData->evCompleteF = completeEvF;
	dmData->translateF = translateF;
	dmData->userData = userData;
	dmData->alloc = alloc;
}

/*$
{function:
	{name: rvMdmDigitMapDataDestruct}
	{class: RvMdmDigitMapData}
	{include: rvmdm.h}
	{description:
		{p: Destructs an RvMdmDigitMapData object.}
	}	
	{proto: void rvMdmDigitMapDataDestruct(RvMdmDigitMapData* dmData);}
	{params:
		{param: {n:dmData} {d:The object.}}
	}
}
$*/
void rvMdmDigitMapDataDestruct(RvMdmDigitMapData* dmData){
	rvMegacoPackageItemDestruct(&dmData->pkgItem);
}

void rvMdmDigitMapDataCopyConstruct(RvMdmDigitMapData* d,RvMdmDigitMapData* s,RvAlloc* a) {
	rvMegacoPackageItemConstructCopy(&d->pkgItem,&s->pkgItem,a);
	d->evCompleteF = s->evCompleteF;
	d->translateF = s->translateF;
	d->userData = s->userData;
	d->alloc = a;
}

/*------------------------------------------------------------------------------*/
/* RvMdmPackage methods				                                            */
/*------------------------------------------------------------------------------*/
static void registerEventInfo(RvMdmPackage* pkg,RvMdmEventData* event);
static void registerSignalInfo(RvMdmPackage *pkg,RvMdmSignalData* signal);

/*------------------------------------------------------------------------------*/
/*$
{function:
	{name: rvMdmPackageRegisterSignal}
	{class: RvMdmPackage}
	{include: rvmdm.h}
	{description:
		{p: Register a signal defined in the package.}
	}	
	{proto: void rvMdmPackageRegisterSignal(RvMdmPackage* x,RvMdmSignalData* signal);}
	{params:
		{param: {n:x} {d:The package object.}}
		{param: {n:signal} {d:The signal data.}}
	}
}
$*/
void rvMdmPackageRegisterSignal(RvMdmPackage* x,RvMdmSignalData* signal) {
	RvMegacoSignal megSig;
	RvMegacoPackageItem name;
	RvMegacoParameterList* params;
	
	/* register the signal info in the map*/
	registerSignalInfo(x,signal);

	/* Build a megaco signal */
	rvMegacoPackageItemConstructA(&name,rvStringGetData(&x->name),
								  rvStringGetData(&signal->id),x->alloc);
	rvMegacoSignalConstructA(&megSig,&name,x->alloc);
	rvMegacoSignalSetType(&megSig,signal->type);
	rvMegacoSignalSetDuration(&megSig,signal->timeout/10);

	params = (RvMegacoParameterList*)rvMegacoSignalGetParameterList(&megSig);
	rvMegacoParameterListCopy(params,&signal->args);

	/* Add to the signal descriptor */
	rvMegacoSignalsDescriptorAddSignal(&x->signals,&megSig);

	/* Delete local objects */
	rvMegacoPackageItemDestruct(&name);
	rvMegacoSignalDestruct(&megSig);
}

/*------------------------------------------------------------------------------*/
/*$
{function:
	{name: rvMdmPackageRegisterEvent}
	{class: RvMdmPackage}
	{include: rvmdm.h}
	{description:
		{p: Register an event defined in the package.}
	}	
	{proto: void rvMdmPackageRegisterEvent(RvMdmPackage* x,RvMdmEventData* event);}
	{params:
		{param: {n:x} {d:The package object.}}
		{param: {n:event} {d:The event data.}}
	}
}
$*/
void rvMdmPackageRegisterEvent(RvMdmPackage* x,RvMdmEventData* event) {
	RvMegacoRequestedEvent megEvent;
	RvMegacoPackageItem name;
	RvMegacoParameterList* params;
	
	/* register the signal info in the map*/
	registerEventInfo(x,event);

	/* Build a megaco signal */
	rvMegacoPackageItemConstructA(&name,rvStringGetData(&x->name),
								  rvStringGetData(&event->id),x->alloc);
	rvMegacoRequestedEventConstructA(&megEvent,&name,x->alloc);

	params = (RvMegacoParameterList*)rvMegacoRequestedEventGetParameterList(&megEvent);
	rvMegacoParameterListCopy(params,&event->args);

	/* Add to the signal descriptor */
	rvMegacoEventsDescriptorAddEvent(&x->events,&megEvent);

	/* Delete local objects */
	rvMegacoPackageItemDestruct(&name);
	rvMegacoRequestedEventDestruct(&megEvent);
}

/*$
{function:
	{name: rvMdmPackageRegisterEventParametersCB }
	{class: RvMdmPackage}
	{include: rvmdm.h}
	{description:
  		{p: Register a callback to process parameters associated a requested event.}
		{p: The MGC set this parameters to customize the generated events.}
	}
	{proto: void rvMdmPackageRegisterEventParametersCB(RvMdmPackage* x,const char* id,RvMdmEventParamCB func);
	}
	{params:
		{param: {n:x} {d:The package.}}
		{param: {n:id} {d:The event id.}}
		{param: {n:func} {d:The callback function.}}
	}
	{notes:
		{note: 
			MEGACO: Call only for events which define EventDescriptor parameters.
		}
	}
}