rvphonesim.c

h.248协议源码

/******************************************************************************
Filename:    rvphonesim.c
Description: termination class for automatic call generation
*******************************************************************************
                Copyright (c) 2001 RADVISION
*******************************************************************************
NOTICE:
This document contains information that is proprietary to RADVISION.
No part of this publication may be reproduced in any form whatsoever 
without written prior approval by RADVISION.

RADVISION reserves the right to revise this publication and make changes
without obligation to notify any person of such revisions or changes.
******************************************************************************/

#include "rvphonesim.h"
#include "rvphysterm.h"
#include "rvmem.h"

#define PHONE_NUMBER_LENGTH 7

typedef struct
{
	RvPhoneSim *mgr;
	RvBool isDialer;
	char digitsToDial[PHONE_NUMBER_LENGTH][3];
} TermInfo;

#define generateEvent(term, pkg, id) rvMdmTermProcessEvent((term), (pkg), (id), 0, NULL)

static RvBool rvPhoneSimStartSignal(RvMdmTerm *term, RvMdmSignal *s, OUT RvMdmError *mdmError)
{
	const char *pkg = rvMdmSignalGetPkg(s);
	const char *id = rvMdmSignalGetId(s);
	if(rvStrIcmp(pkg, "cg") == 0)
	{
		if(rvStrIcmp(id, "dt") == 0)
		{
			TermInfo *info = (TermInfo *)rvMdmTermGetUserData(term);
			int i;
			for(i=0; i<PHONE_NUMBER_LENGTH; ++i)
			{
				generateEvent(term, "dd", info->digitsToDial[i]);
			}
		}
		else if(rvStrIcmp(id, "bt") == 0)
		{
			generateEvent(term, "al", "on");
		}
	}
	else if(rvStrIcmp(pkg, "al") == 0 && rvStrIcmp(id, "ri") == 0)
	{
		generateEvent(term, "al", "of");
	}
	return rvTrue;
}

static RvBool rvPhoneSimStopSignal(RvMdmTerm *term, RvMdmSignal *s, OUT RvMdmError *mdmError)
{
	const char *pkg = rvMdmSignalGetPkg(s);
	const char *id = rvMdmSignalGetId(s);
	if(rvStrIcmp(pkg, "cg") == 0 && rvStrIcmp(id, "rt") == 0)
	{
		generateEvent(term, "al", "on");
	}
	return rvTrue;
}

static RvBool rvPhoneSimOnRequestOffHook(RvMdmTerm *termination, 
					  const char *pkg, const char *name, RvMdmMediaStream *mediaStream,
					  const RvMegacoParameterList *parameters, RvMdmError *errorInfo)
{
	TermInfo *info = (TermInfo *)rvMdmTermGetUserData(termination);
	if(info->isDialer)
		generateEvent(termination, "al", "of");
	return rvTrue;
}

static RvBool rvPhoneSimOnRequestOnHook(RvMdmTerm *termination, 
					  const char *pkg, const char *name, RvMdmMediaStream *mediaStream,
					  const RvMegacoParameterList *parameters, RvMdmError *errorInfo)
{
	TermInfo *info = (TermInfo *)rvMdmTermGetUserData(termination);
	if(!info->isDialer)
		generateEvent(termination, "al", "on");
	return rvTrue;
}

static void rvPhoneSimRegisterPhones(RvPhoneSim *mgr, const char *prefix, int numTerms)
{
	RvMdmTermDefaultProperties termProperties;
	RvMdmServiceChange sc;
	int i;

	rvMdmTermDefaultPropertiesConstruct(&termProperties);

	rvMdmServiceChangeConstruct(&sc);
	rvMdmServiceChangeSetMethod(&sc, RV_MEGACOSERVICECHANGEMETHOD_RESTART);
	rvMdmServiceChangeSetReason(&sc, RV_MEGACOSERVICECHANGEREASON_SERVICERESTORED);
	
	for(i=0; i<numTerms; ++i)
	{
		char termName[32];
		RvMdmTerm *termination;
		TermInfo *info;

		sprintf(termName, "rv/%s/%d", prefix, i);

		termination = rvMdmTermMgrRegisterPhysicalTermination(mgr->termMgr,
			mgr->phoneClass, termName, &termProperties, &sc);

		info = (TermInfo *)rvAllocAllocate(&rvDefaultAlloc, sizeof(TermInfo));
		
		info->mgr = mgr;

		/* odd numbered phone i will dial phone i-1 */
		if(info->isDialer = (i & 1) != 0)
		{
			char phoneNum[PHONE_NUMBER_LENGTH + 1];
			int n;
			sprintf(phoneNum, "%s%0*d", prefix, PHONE_NUMBER_LENGTH - strlen(prefix), i-1);
			for(n=0; n<PHONE_NUMBER_LENGTH; ++n)
				sprintf(info->digitsToDial[n], "d%c", phoneNum[n]);
		}

		rvMdmTermSetUserData(termination, info);
	}

	rvMdmServiceChangeDestruct(&sc);
	rvMdmTermDefaultPropertiesDestruct(&termProperties);
}

static RvBool rvPhoneSimCreateMedia(RvMdmTerm *termination,
	RvMdmMediaStream *media, RvMdmMediaStreamDescr *streamDescr, RvMdmError *mdmError)
{
	TermInfo *info = (TermInfo *)rvMdmTermGetUserData(termination);
	RvRtpLink *rtpLink = (RvRtpLink *)rvAllocAllocate(&rvDefaultAlloc, sizeof(RvRtpLink));

	rvRtpLinkConstruct(rtpLink, info->mgr->engine);
	rvRtpLinkSetMode(rtpLink, RV_MEGACOSTREAMMODE_INACTIVE);
	rvMdmMediaStreamSetUserData(media, rtpLink);
	
	return rvTrue;
}

static RvBool rvPhoneSimModifyMedia(RvMdmTerm *termination,
	RvMdmMediaStream *media, RvMdmMediaStreamDescr *streamDescr, RvMdmError *mediaError)
{
	return rvTrue;
}

static RvBool rvPhoneSimDestroyMedia(RvMdmTerm *termination, RvMdmMediaStream *media, RvMdmError *mdmError)
{
	RvRtpLink *rtpLink = (RvRtpLink *)rvMdmMediaStreamGetUserData(media);

	rvRtpLinkDestruct(rtpLink);
	rvAllocDeallocate(&rvDefaultAlloc, sizeof(RvRtpLink), rtpLink);
	
	return rvTrue;
}

RvRtpLink *rvPhoneSimGetRtpLink(RvMdmMediaStream *media)
{
	return (RvRtpLink *)rvMdmMediaStreamGetUserData(media);
}

RvPhysTermData rvPhoneSimClassData = { rvPhoneSimGetRtpLink,
	rvPhoneSimOnRequestOffHook, rvPhoneSimOnRequestOnHook };

static int getMaxTerms(const char *prefix)
{
	int termDigits = PHONE_NUMBER_LENGTH - strlen(prefix);
	int maxTerms = 1;
	int i;

	if(termDigits < 0)
		return 0;
	for(i=0; i<termDigits; ++i)
		maxTerms *= 10;
	return maxTerms;
}

RvPhoneSim *rvPhoneSimConstruct(RvPhoneSim *mgr, RvMdmTermMgr *termMgr,
	rtpEngine *engine, const char *prefix, int numTerms)
{
	if(numTerms > getMaxTerms(prefix))
		return NULL;

	mgr->termMgr = termMgr;
	mgr->phoneClass = rvMdmTermMgrCreateTermClass(termMgr);
	mgr->engine = engine;

	rvMdmTermClassRegisterStartSignalCB(mgr->phoneClass, rvPhoneSimStartSignal);
	rvMdmTermClassRegisterStopSignalCB(mgr->phoneClass, rvPhoneSimStopSignal);
	rvMdmTermClassRegisterCreateMediaCB(mgr->phoneClass, rvPhoneSimCreateMedia);
	rvMdmTermClassRegisterModifyMediaCB(mgr->phoneClass, rvPhoneSimModifyMedia);
	rvMdmTermClassRegisterDestroyMediaCB(mgr->phoneClass, rvPhoneSimDestroyMedia);	
	rvMdmTermClassAddSupportedPkg(mgr->phoneClass, "al", 0);
	rvMdmTermClassAddSupportedPkg(mgr->phoneClass, "cg", 0);
	rvMdmTermClassAddSupportedPkg(mgr->phoneClass, "dd", 0);
	rvMdmTermClassSetUserData(mgr->phoneClass, &rvPhoneSimClassData);

	rvPhoneSimRegisterPhones(mgr, prefix, numTerms);
	return mgr;
}

void rvPhoneSimDestruct(RvPhoneSim *mgr)
{
}