UByte voice_callUser(PPIDType called, PPIDType caller)
{
ApplicationInstanceType *applicationInstanceData;
if (QuickData[called].EmptyMarker == 0) {
SignalType * signal;
NewSignal(sizeof(SignalType), (void**) &signal);
PPID2PMID((PMIDType *) signal->Address, called);
applicationInstanceData = getApplicationInstance(signal->Address);
if (applicationInstanceData->state == idle) {
applicationInstanceData->state = incommingcall;
applicationInstanceData->connectedTo = caller;
SendSignal((SignalType*) signal, APP_CC_PROCESS_ID, APP_CC_PRIMITIVE, APPCCSetupReq);
/*setup the outgoing side of the call:*/
{
PMIDType pmid;
char tmp[13];
UByte sum = called;
PPID2PMID(&pmid, caller);
applicationInstanceData = getApplicationInstance(pmid);
applicationInstanceData->connectedTo = called;
memset(tmp, 0, 12);
tmp[0] = sum + '0';
handleConnectPrim(pmid, applicationInstanceData);
/*{
AudioLineCtrlReqType *AudioLineCtrlReq;
NewSignal(sizeof(AudioLineCtrlReqType), (void **) &AudioLineCtrlReq);
AudioLineCtrlReq->TheSignal.Address[0] = 0x0F;
AudioLineCtrlReq->TheSignal.Address[1] = 0;//MeInstance->Mcei;
AudioLineCtrlReq->Lid = sum;
_memcpy(AudioLineCtrlReq->Pmid,pmid,3);
AudioLineCtrlReq->option = 3;
PrintStatus(0, "\r\napp: send AUDIOLINECTRL_req to mac layer");
SendSignal((SignalType*)AudioLineCtrlReq, CCF_PROCESS_ID, CCF_PRIMITIVE, AUDIOLINECTRL_req);
}*/
}
return 1;
} else {
DeleteBuffer(signal);
PrintStatus(0, "\r\nnumber found, but user allready active.\n");
return 2;
}
} else {
PrintStatus(0, "\r\nnumber not found...");
return 3;
}
}
UByte voice_disConnectUser(PPIDType user)
{
if (QuickData[user].EmptyMarker == 0) {
ApplicationInstanceType *applicationInstanceData;
PMIDType pmid;
PPID2PMID((PMIDType *) pmid, user);
applicationInstanceData = getApplicationInstance(pmid);
if (applicationInstanceData->state == connected) {
SignalType *CcReleasePrim;
UByte Data[2] = { 0x2e, 00 };
NewSignal(sizeof(SignalType) + 2, (void **) &CcReleasePrim);
memcpy(CcReleasePrim->Address, pmid, 3);
CcReleasePrim->Address[3] = 0x00;
_memcpy(getCcReleasePrimTypeIE(CcReleasePrim), Data, 2);
SendSignal((SignalType *) CcReleasePrim, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_RELEASE_prim);
applicationInstanceData->state = idle;
return 0;
} else {
return 2;
}
} else {
return 3;
}
}
UByte voice_updateDisplay(PPIDType user, char * display)
{
SignalType *ccinfoSignal;
ApplicationInstanceType *applicationInstanceData;
PPID2PMID(&tmpPmid, user);
applicationInstanceData = getApplicationInstance(tmpPmid);
if (user != 0xffff && applicationInstanceData != NULL) {
NewSignal(sizeof(SignalType) + 14, (void**) &ccinfoSignal);
memcpy(ccinfoSignal->Address, tmpPmid, 3); /*pmid in address field*/
getSignalData(ccinfoSignal)[0] = 0x01; /*info element offset*/
getSignalData(ccinfoSignal)[1] = 0x28;
getSignalData(ccinfoSignal)[2] = 0x02 + strlen(display);
getSignalData(ccinfoSignal)[3] = 0x04;
getSignalData(ccinfoSignal)[4] = 0x0C;
memcpy(getSignalData(ccinfoSignal) + 5, display, strlen(display)); /*multidisplay, iwutoiwu, signal*/
SendSignal(ccinfoSignal, APP_CC_PROCESS_ID, APP_CC_PRIMITIVE, APPCCInfoReq);
return 1;
}
return 0;
}
int IFCBuilder::getOwnerHistoryInstance()
{
if (!ifcBuildOwnerHistoryInstance) {
ifcBuildOwnerHistoryInstance = sdaiCreateInstanceBN(model, "IFCOWNERHISTORY");
sdaiPutAttrBN(ifcBuildOwnerHistoryInstance, "OwningUser", sdaiINSTANCE, (void*) getPersonAndOrganizationInstance());
sdaiPutAttrBN(ifcBuildOwnerHistoryInstance, "OwningApplication", sdaiINSTANCE, (void*) getApplicationInstance());
sdaiPutAttrBN(ifcBuildOwnerHistoryInstance, "ChangeAction", sdaiENUM, "ADDED");
sdaiPutAttrBN(ifcBuildOwnerHistoryInstance, "CreationDate", sdaiINTEGER, (void*) getTimeStamp());
}
return ifcBuildOwnerHistoryInstance;
}
ApplicationInstanceType * getApplicationInstanceData(PPIDType ppid)
{
PMIDType pmid;
PPID2PMID(&pmid, ppid);
return getApplicationInstance(pmid);
}
void ApplicationSignalHandler_FP(SignalType * TheSignal)
{
ApplicationInstanceType * applicationInstanceData;
if (common_signalHander(TheSignal)) {
return;
}
if (TheSignal->Event == INITIALIZE_EVENT) {
InitializeTreeTop(&applicationTree, sizeof(PMIDType));
DeleteBuffer(TheSignal);
fp_system_init();
return;
}
applicationInstanceData = getApplicationInstance(TheSignal->Address);
switch (TheSignal->Event)
{
case APPLICATION_PRIMITIVE:
{
switch (TheSignal->SubEvent)
{
case APPCCSetupInd:
{
handleAPPCCSetupInd(TheSignal, applicationInstanceData);
}
break;
case APPCCInfoInd:
{
handleAPPCCInfoInd(TheSignal, applicationInstanceData);
}
break;
case APPCCAbnormal:
{
if (applicationInstanceData) {
PrintStatus(0, "abnormal release in application, user found");
handleReleasePrim(TheSignal, applicationInstanceData);
} else {
_sprintf_(StatusString, "abnormal %x %x %x %x", TheSignal->Address[0], TheSignal->Address[1], TheSignal->Address[2], TheSignal->Address[3]);
PrintStatus(0, StatusString);
}
}
break;
case 0x86:
{
UByte * data = getSignalData(TheSignal);
fp_module2module_ack_received(PMID2PPID(TheSignal->Address), &data[1]);
}
break;
case SS_MSF_prim:
{
UByte *messageData;
UByte DestinationIdLenght;
UByte *DestinationId;
UByte DisplaytextLength;
UByte *DisplayText;
UByte CallBackNumberLength;
UByte *CallBackNumber;
UByte SSAAAD[SSAAADLength];
int index, count;
APPMSFind* appMSFind = (APPMSFind*) TheSignal;
char* tmp;
index = 0;
messageData = getAPPMSFindIE(appMSFind);
DestinationIdLenght = messageData[index++];
DestinationId = (UByte*) mem_malloc(DestinationIdLenght + 1, 0x42);
for (count = 0; count < DestinationIdLenght; count++) {
DestinationId[count] = messageData[index++];
}
DestinationId[count] = '\0';
DisplaytextLength = messageData[index++];
DisplayText = (UByte*) mem_malloc(DisplaytextLength + 1, 0x42);
for (count = 0; count < DisplaytextLength; count++) {
DisplayText[count] = messageData[index++];
}
DisplayText[count] = '\0';
CallBackNumberLength = messageData[index++];
CallBackNumber = (UByte*) mem_malloc(CallBackNumberLength + 1, 0x42);
for (count = 0; count < CallBackNumberLength; count++) {
CallBackNumber[count] = messageData[index++];
}
CallBackNumber[count] = '\0';
memcpy(&SSAAAD[0], &messageData[index], SSAAADLength);
tmp = StatusString;
tmp = StringPrint(tmp, "MSF: [");
tmp = StringPrint(tmp, (char*) DisplayText);
tmp = StringPrint(tmp, "] from [");
tmp = StringPrint(tmp, (char*) CallBackNumber);
tmp = StringPrint(tmp, "] to [");
tmp = StringPrint(tmp, (char*) DestinationId);
tmp = StringPrint(tmp, "]");
PrintStatus(0, StatusString);
if (strlen((char*) DisplayText) == 1) {
if ((DisplayText[0] >= '0') && (DisplayText[0] <= '9')) {
char * ptr = StringPrint(StatusString, "Dialing: ");
UByte receiver = DisplayText[0] - '0';
ptr = StrPrintHexByte(ptr, receiver);
PrintStatus(0, StatusString);
/*callUser((char*) DisplayText, 0, "Call from FP");*/
}
}
msf_outgMessageIndReceived(PMID2PPID(TheSignal->Address), SSAAAD[0], SSAAAD[1], SSAAAD[2], SSAAAD[3], SSAAAD[4], SSAAAD[5], (char*) DestinationId, (char*) DisplayText, PMID2PPID(TheSignal->Address));
mem_free(DestinationId);
mem_free(DisplayText);
mem_free(CallBackNumber);
}
break;
}
}
break;
case IWU_PRIMITIVE:
{
switch (TheSignal->SubEvent)
{
case CC_ALERTING_prim:
{
if (applicationInstanceData != NULL) {
voice_incommingCallAlerting(PMID2PPID(applicationInstanceData->pmid), applicationInstanceData->connectedTo);
}
PrintStatus(0, "Application: alerting....\n");
}
break;
case CC_CONNECT_prim:
{
extern void setupvoice(PPIDType a, PPIDType b);
setupvoice(PMID2PPID(applicationInstanceData->pmid), applicationInstanceData->connectedTo);
PrintStatus(0, "fp_application: CC_CONNECT_prim");
handleConnectPrim(TheSignal->Address, applicationInstanceData);
voice_callConnected(PMID2PPID(applicationInstanceData->pmid), applicationInstanceData->connectedTo);
}
break;
case CC_RELEASE_prim:
{
ApplicationInstanceType * wasConnectedTo;
PPID2PMID(&tmpPmid, applicationInstanceData->connectedTo);
wasConnectedTo = getApplicationInstance(tmpPmid);
wasConnectedTo->connectedTo = 0xffff;
voice_callDisconnected(PMID2PPID(applicationInstanceData->pmid), applicationInstanceData->connectedTo, 0x00);
handleReleasePrim(TheSignal, applicationInstanceData);
}
break;
};
}
break;
case APP_SS_PRIMITIVE:
{
switch (TheSignal->SubEvent)
{
case SIO_MSF_SETUP_req: /*from serial / ip*/
{
}
break;
case SIO_MSF_SETUP_ind: /*from pp*/
{
applicationInstanceData->msfState = msf_session_requested_from_pp;
msf_msfsetupIndReceived(PMID2PPID(TheSignal->Address), (char*) getSignalData(TheSignal));
}
break;
case SIO_MSF_CONNECT_res:
{
/*SioMsfConnectResType *SioMsfConnectRes = (SioMsfConnectResType *) TheSignal;*/
}
break;
case SIO_MSF_CONNECT_cfm:
{
msf_connectCfmReceived(PMID2PPID(TheSignal->Address));
}
break;
case SIO_MSF_INFO_ind:
{
msf_infoIndReceived(PMID2PPID(TheSignal->Address), getSignalData(TheSignal)[0]);
}
break;
case SIO_MSF_INFO_req:
{
/*SioMsfInfoReqType *SioMsfInfoReq = (SioMsfInfoReqType *) TheSignal;*/
}
break;
case SIO_MSF_RELEASE_req:
{
/*SioMsfReleaseReqType *SioMsfReleaseReq = (SioMsfReleaseReqType *) TheSignal;*/
}
break;
case SIO_MSF_RELEASE_ind:
{
applicationInstanceData->msfState = msf_idle;
msf_releaseIndReceived(PMID2PPID(applicationInstanceData->pmid), getSignalData(TheSignal)[0]);
}
break;
case SIO_MSF_OUTG_MESSAGE_ind:
{
}
break;
case SIO_PP_STATUS_req:
{
/*SioPpStatusReadReqType *SioPpStatusReq = (SioPpStatusReadReqType *) TheSignal;*/
/*int i = 0;*/
}
break;
case SIO_PP_STATUS_ind:
{
SioPpStatusIndType *SioPpStatusInd;
SioPpStatusInd = (SioPpStatusIndType*) TheSignal;
msf_ppstatus_ind_received(PMID2PPID(applicationInstanceData->pmid), SioPpStatusInd->StatusType, getSioPpStatusIndTypeIE(SioPpStatusInd), SioPpStatusInd->SignalHeader.SignalLength
- offsetof(SioPpStatusIndType,StatusType) - 1);
}
break;
}
}
break;
case TIME_OUT_EVENT:
{
TimerType * timerPtr = (TimerType*) TheSignal;
PMIDType pmid;
UByte dataLength = TheSignal->SignalLength - timerSize();
PPID2PMID(&pmid, (PPIDType) -1);
if (memcmp(TheSignal->Address, pmid, sizeof(PMIDType)) != 0) {
getApplicationInstance(TheSignal->Address)->timer = NULL;
}
fp_general_timeout(PMID2PPID(TheSignal->Address), TheSignal->SubEvent, getTimerData(timerPtr), dataLength);
}
break;
};
DeleteBuffer(TheSignal);
}
