--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyutils/etel3rdpartyapi/src/TelephonyFuncLine.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,398 @@
+/*
+* Copyright (c) 2009 Sony Ericsson Mobile Communications AB
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Sony Ericsson Mobile Communications AB - initial contribution.
+* Nokia Corporation - additional changes.
+*
+* Contributors:
+*
+* Description:
+* Code for TelephonyFuncLine class, used by CTelephony class.
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include <e32def.h>
+#include "TelephonyFunctions.h"
+
+
+TInt CTelephonyFunctions::GetLineStatus(const CTelephony::TPhoneLine& aLine, TDes8& aStatus)
+/**
+Get the current line status.
+*/
+ {
+ TInt ret=KErrAccessDenied;
+
+ if(IsFlightModeOn())
+ {
+ return KErrAccessDenied;
+ }
+
+ CTelephony::TCallStatusV1& CallStatusV1 = reinterpret_cast<CTelephony::TCallStatusV1&> ( const_cast<TUint8&> ( *aStatus.Ptr() ) );
+ RMobileCall::TMobileCallStatus callStatus=RMobileCall::EStatusUnknown;
+
+ switch(aLine)
+ {
+ case CTelephony::EVoiceLine:
+ ret= iLineVoice.GetMobileLineStatus(callStatus);
+ break;
+ case CTelephony::EDataLine:
+ if(iLineIsDataOpen)
+ {
+ ret= iLineData.GetMobileLineStatus(callStatus);
+ }
+ else
+ {
+ return KErrNotSupported;
+ }
+ break;
+ case CTelephony::EFaxLine:
+ if(iLineIsFaxOpen)
+ {
+ ret= iLineFax.GetMobileLineStatus(callStatus);
+ }
+ else
+ {
+ return KErrNotSupported;
+ }
+ break;
+ default:
+ return KErrNotFound;
+ }
+ GetCallStatus(callStatus, CallStatusV1.iStatus);
+ return ret;
+ }
+
+LOCAL_C void CloseArrayOfCallObjects(TAny* aCallArray)
+/**
+Close and delete the call object array.
+*/
+ {
+ CArrayFixFlat<RMobileCall>* callArray = reinterpret_cast<CArrayFixFlat<RMobileCall>*>(aCallArray);
+ TInt count = callArray->Count();
+ for (TInt i=count-1; i>=0; --i)
+ {
+ callArray->At(i).Close();
+ }
+ delete callArray;
+ callArray = NULL;
+ }
+
+TInt CTelephonyFunctions::GetCallInfoL(TDes8& aCallSelect, TDes8& aCallInfo, TDes8& aRemoteInfo)
+/**
+Get the current call information.
+*/
+ {
+ CTelephony::TCallSelectionV1& CallSelectionV1 = reinterpret_cast<CTelephony::TCallSelectionV1&>
+ ( const_cast<TUint8&> ( *aCallSelect.Ptr() ) );
+
+ if(CallSelectionV1.iLine != CTelephony::EVoiceLine)
+ {
+ return KErrAccessDenied;
+ }
+
+ if(IsFlightModeOn())
+ {
+ return KErrAccessDenied;
+ }
+
+ CTelephony::TCallInfoV1& CallInfoV1 = reinterpret_cast<CTelephony::TCallInfoV1&>
+ ( const_cast<TUint8&> ( *aCallInfo.Ptr() ) );
+
+ CTelephony::TRemotePartyInfoV1& RemotePartyInfoV1 = reinterpret_cast<CTelephony::TRemotePartyInfoV1&>
+ ( const_cast<TUint8&> ( *aRemoteInfo.Ptr() ) );
+
+ TPtr8* callInfoPkgPtr;
+ RMobileCall::TMobileCallInfoV1* callInfoObjPtr;
+
+ if(iTsyVersion == KNoMultimodeTsy)
+ {
+ return KErrNotSupported;
+ }
+ else if(iTsyVersion==KETelExtMultimodeV1 || iTsyVersion==KETelExtMultimodeV2)
+ {
+ RMobileCall::TMobileCallInfoV1* callInfoV1 = new(ELeave) RMobileCall::TMobileCallInfoV1;
+ CleanupStack::PushL(callInfoV1);
+ RMobileCall::TMobileCallInfoV1Pckg* callInfoV1Pckg = new(ELeave) RMobileCall::TMobileCallInfoV1Pckg(*callInfoV1);
+ CleanupStack::PushL(callInfoV1Pckg);
+ callInfoPkgPtr = callInfoV1Pckg;
+ callInfoObjPtr = callInfoV1;
+ }
+ else //TSY v3
+ {
+ RMobileCall::TMobileCallInfoV3* callInfoV3 = new(ELeave) RMobileCall::TMobileCallInfoV3;
+ CleanupStack::PushL(callInfoV3);
+ RMobileCall::TMobileCallInfoV3Pckg* callInfoV3Pckg = new(ELeave) RMobileCall::TMobileCallInfoV3Pckg(*callInfoV3);
+ CleanupStack::PushL(callInfoV3Pckg);
+ callInfoPkgPtr = callInfoV3Pckg;
+ callInfoObjPtr = callInfoV3;
+ }
+
+ TInt numOfCalls=0;
+ User::LeaveIfError(iLineVoice.EnumerateCall(numOfCalls));
+ if (numOfCalls==0)
+ {
+ User::Leave(KErrNotFound);
+ }
+ CArrayFixFlat<RMobileCall>* tempCallArray = new (ELeave) CArrayFixFlat<RMobileCall>(numOfCalls);
+ CleanupStack::PushL(TCleanupItem(CloseArrayOfCallObjects, tempCallArray));
+ TInt i;
+
+ RLine::TCallInfo callinfo;
+ RMobileCall::TMobileCallStatus callStatus;
+ TBool callFound=EFalse;
+ for(i=0; i<numOfCalls; i++)
+ {
+ User::LeaveIfError(iLineVoice.GetCallInfo(i,callinfo));
+ RMobileCall tempCall;
+
+ tempCallArray->AppendL(tempCall);
+ User::LeaveIfError(tempCallArray->At(i).OpenExistingCall(iLineVoice,callinfo.iCallName));
+ User::LeaveIfError(tempCallArray->At(i).GetMobileCallStatus(callStatus));
+
+ if((callStatus==RMobileCall::EStatusConnected) &&
+ (CallSelectionV1.iSelect==CTelephony::EActiveCall))
+ {
+ User::LeaveIfError(tempCallArray->At(i).GetMobileCallInfo(*callInfoPkgPtr));
+ callFound=ETrue;
+ break;
+ }
+ else if((callStatus==RMobileCall::EStatusHold) &&
+ (CallSelectionV1.iSelect==CTelephony::EHeldCall))
+ {
+ User::LeaveIfError(tempCallArray->At(i).GetMobileCallInfo(*callInfoPkgPtr));
+ callFound=ETrue;
+ break;
+ }
+ else if(((callStatus==RMobileCall::EStatusDialling) ||
+ (callStatus==RMobileCall::EStatusRinging) ||
+ (callStatus==RMobileCall::EStatusAnswering) ||
+ (callStatus==RMobileCall::EStatusConnecting) ||
+ (callStatus==RMobileCall::EStatusReconnectPending) ||
+ (callStatus==RMobileCall::EStatusDisconnecting) ||
+ (callStatus==RMobileCall::EStatusDisconnectingWithInband) ||
+ (callStatus==RMobileCall::EStatusTransferring) ||
+ (callStatus==RMobileCall:: EStatusTransferAlerting)
+ ) &&
+ (CallSelectionV1.iSelect==CTelephony::EInProgressCall))
+ {
+ User::LeaveIfError(tempCallArray->At(i).GetMobileCallInfo(*callInfoPkgPtr));
+ callFound=ETrue;
+ break;
+ }
+
+ }
+
+ CleanupStack::PopAndDestroy(tempCallArray); //tempCallArray
+ if(!callFound)
+ {
+ CleanupStack::PopAndDestroy(2); //(callInfoV1Pckg or callInfoV3Pckg) AND (callInfoV1 or callInfoV3)
+ return KErrNotFound;
+ }
+
+ GetCallStatus(callInfoObjPtr->iStatus, CallInfoV1.iStatus);
+
+ if (callInfoObjPtr->iValid & RMobileCall::KCallSecurity)
+ {
+ if(callInfoObjPtr->ExtensionId() == KETelExtMultimodeV3)
+ {
+ RMobileCall::TMobileCallInfoV3* callInfoV3Ptr = reinterpret_cast<RMobileCall::TMobileCallInfoV3*>(callInfoObjPtr);
+
+ switch(callInfoV3Ptr->iSecurity)
+ {
+ case RMobilePhone::ECipheringGSM:
+ CallInfoV1.iSecurity = CTelephony::ECipheringGSM;
+ break;
+ case RMobilePhone::ECipheringWCDMA:
+ CallInfoV1.iSecurity = CTelephony::ECipheringWCDMA;
+ break;
+ case RMobilePhone::ECipheringOff:
+ default:
+ CallInfoV1.iSecurity = CTelephony::ECipheringOff;
+ break;
+ }
+ }
+ else
+ CallInfoV1.iSecurity = CTelephony::ECipheringOff;
+ }
+ else
+ {
+ CallInfoV1.iSecurity = CTelephony::TPhoneNetworkSecurity();
+ }
+
+
+ if (callInfoObjPtr->iValid & RMobileCall::KCallStartTime)
+ {
+ CallInfoV1.iStartTime = callInfoObjPtr->iStartTime;
+ }
+ else
+ {
+ CallInfoV1.iStartTime = TDateTime();
+ }
+ if (callInfoObjPtr->iValid & RMobileCall::KCallDuration)
+ {
+ CallInfoV1.iDuration = callInfoObjPtr->iDuration;
+ }
+ else
+ {
+ CallInfoV1.iDuration = 0;
+ }
+ if (callInfoObjPtr->iValid & RMobileCall::KCallExitCode)
+ {
+ CallInfoV1.iExitCode = callInfoObjPtr->iExitCode;
+ }
+ else
+ {
+ CallInfoV1.iExitCode = 0;
+ }
+
+ if (callInfoObjPtr->iValid & RMobileCall::KCallDialledParty)
+ {
+ CopyTelAddress(callInfoObjPtr->iDialledParty, CallInfoV1.iDialledParty);
+ }
+ else
+ {
+ CallInfoV1.iDialledParty = CTelephony::TTelAddress();
+ }
+
+ //see whether we have an existing handle on the call
+ CallInfoV1.iCallId = -1;
+ RMobileCall* poolCall=NULL;
+ RMobileCall::TMobileCallInfoV1 poolCallInfoV1;
+ RMobileCall::TMobileCallInfoV1Pckg poolCallInfoV1Pckg(poolCallInfoV1);
+ TInt err;
+
+ for(int k=0;k<CTelephony::EISVMaxNumOfCalls;k++)
+ {
+ //get RMobileCall object
+ if((poolCall = Call((CTelephony::TCallId)k)) != NULL)
+ {
+ //get call name
+ err = poolCall->GetMobileCallInfo(poolCallInfoV1Pckg);
+ if(err ==KErrNone)
+ {
+ //compare call names
+ if(poolCallInfoV1.iCallName.MatchF(callinfo.iCallName)==0)
+ {
+ CallInfoV1.iCallId = k;
+ break;
+ }
+ }
+ }
+ }
+
+ //fill TRemotePartyInfoV1
+ RMobileCall::TMobileCallRemotePartyInfoV1& mobileRemoteParty = callInfoObjPtr->iRemoteParty;
+
+ switch(mobileRemoteParty.iRemoteIdStatus)
+ {
+ case RMobileCall::ERemoteIdentityAvailable:
+ RemotePartyInfoV1.iRemoteIdStatus = CTelephony::ERemoteIdentityAvailable;
+ break;
+ case RMobileCall::ERemoteIdentitySuppressed:
+ RemotePartyInfoV1.iRemoteIdStatus = CTelephony::ERemoteIdentitySuppressed;
+ break;
+ case RMobileCall::ERemoteIdentityUnknown:
+ default:
+ RemotePartyInfoV1.iRemoteIdStatus = CTelephony::ERemoteIdentityUnknown;
+ break;
+ }
+
+ RemotePartyInfoV1.iCallingName.Copy(mobileRemoteParty.iCallingName);
+ CopyTelAddress(mobileRemoteParty.iRemoteNumber, RemotePartyInfoV1.iRemoteNumber);
+
+ switch(mobileRemoteParty.iDirection)
+ {
+ case RMobileCall::EMobileOriginated:
+ RemotePartyInfoV1.iDirection = CTelephony::EMobileOriginated;
+ break;
+ case RMobileCall::EMobileTerminated:
+ RemotePartyInfoV1.iDirection = CTelephony::EMobileTerminated;
+ break;
+ case RMobileCall::EDirectionUnknown:
+ default:
+ RemotePartyInfoV1.iDirection = CTelephony::EDirectionUnknown;
+ break;
+ }
+
+ CleanupStack::PopAndDestroy(2); //(callInfoV1Pckg or callInfoV3Pckg) AND (callInfoV1 or callInfoV3)
+
+ return KErrNone;
+ }
+
+void CTelephonyFunctions::CopyTelAddress(const RMobilePhone::TMobileAddress& aFromAddress, CTelephony::TTelAddress& aToAddress)
+/**
+Maps a RMobilePhone::TMobileAddress object to a CTelephony::TTelAddress object.
+*/
+ {
+ aToAddress.iTelNumber.Copy(aFromAddress.iTelNumber);
+
+ switch(aFromAddress.iTypeOfNumber)
+ {
+ case RMobilePhone::EInternationalNumber:
+ aToAddress.iTypeOfNumber=CTelephony::EInternationalNumber;
+ break;
+ case RMobilePhone::ENationalNumber:
+ aToAddress.iTypeOfNumber=CTelephony::ENationalNumber;
+ break;
+ case RMobilePhone::ENetworkSpecificNumber:
+ aToAddress.iTypeOfNumber=CTelephony::ENetworkSpecificNumber;
+ break;
+ case RMobilePhone::ESubscriberNumber:
+ aToAddress.iTypeOfNumber=CTelephony::ESubscriberNumber;
+ break;
+ case RMobilePhone::EAlphanumericNumber:
+ aToAddress.iTypeOfNumber=CTelephony::EAlphanumericNumber;
+ break;
+ case RMobilePhone::EAbbreviatedNumber:
+ aToAddress.iTypeOfNumber=CTelephony::EAbbreviatedNumber;
+ break;
+ case RMobilePhone::EUnknownNumber:
+ default:
+ aToAddress.iTypeOfNumber=CTelephony::EUnknownNumber;
+ break;
+ }
+
+ switch(aFromAddress.iNumberPlan)
+ {
+ case RMobilePhone::EIsdnNumberPlan:
+ aToAddress.iNumberPlan=CTelephony::EIsdnNumberPlan;
+ break;
+ case RMobilePhone::EDataNumberPlan:
+ aToAddress.iNumberPlan=CTelephony::EDataNumberPlan;
+ break;
+ case RMobilePhone::ETelexNumberPlan:
+ aToAddress.iNumberPlan=CTelephony::ETelexNumberPlan;
+ break;
+ case RMobilePhone::EServiceCentreSpecificPlan1:
+ aToAddress.iNumberPlan=CTelephony::EServiceCentreSpecificPlan1;
+ break;
+ case RMobilePhone::EServiceCentreSpecificPlan2:
+ aToAddress.iNumberPlan=CTelephony::EServiceCentreSpecificPlan2;
+ break;
+ case RMobilePhone::ENationalNumberPlan:
+ aToAddress.iNumberPlan=CTelephony::ENationalNumberPlan;
+ break;
+ case RMobilePhone::EPrivateNumberPlan:
+ aToAddress.iNumberPlan=CTelephony::EPrivateNumberPlan;
+ break;
+ case RMobilePhone::EERMESNumberPlan:
+ aToAddress.iNumberPlan=CTelephony::EERMESNumberPlan;
+ break;
+ case RMobilePhone::EUnknownNumberingPlan:
+ default:
+ aToAddress.iNumberPlan=CTelephony::EUnknownNumberingPlan;
+ break;
+ }
+ }
+