FCL/sf/os/cellularsrv: comparison telephonyserverplugins/common

equal deleted inserted replaced

-:6fbc08ed9c42
+:930a53cdc2d3
 // Reset all CMmUssdTsy variables
 ResetVariables();
 // Initialize boolean flag
 iUssdNoFdnCheckFlag =  EUssdNoFdnCheckUnknown;
+iSendToDefaultHandler = EFalse;
 }
 CMmUssdTsy* CMmUssdTsy::NewL(
 CMmPhoneTsy* aMmPhone )
 {
 aPackage.Des2n() );
 break;
 case EMobileUssdMessagingSendMessage:
 {
 iUssdNoFdnCheckFlag = EUssdNoFdnCheckNotUsed;
+iSendToDefaultHandler = EFalse;
 ret = SendMessageL(
 aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n() );
 }
 break;
+case EMobileUssdMessagingSendMessageDefaultHandler:
+			{
+			iUssdNoFdnCheckFlag = EUssdNoFdnCheckNotUsed;
+			iSendToDefaultHandler = ETrue;
+			ret = SendMessageL(
+				aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n() );
+			}
+			break;
 case EMobileUssdMessagingSendMessageNoFdnCheck:
 {
 iUssdNoFdnCheckFlag = EUssdNoFdnCheckUsed;
+iSendToDefaultHandler = EFalse;
 ret = SendMessageL(
 aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n() );
 }
 break;
 case EMobileUssdMessagingSendRelease:
 break;
 case EMobileUssdMessagingSendMessage:
 SendMessageCancel( aTsyReqHandle );
 ret = KErrNone;
 break;
+case EMobileUssdMessagingSendMessageDefaultHandler:
+	SendMessageCancelDefaultHandler( aTsyReqHandle );
+	ret = KErrNone;
+	break;
 case EMobileUssdMessagingSendMessageNoFdnCheck:
 SendMessageNoFdnCheckCancel( aTsyReqHandle );
 ret = KErrNone;
 break;
 case EMobileUssdMessagingSendRelease:
 case EMobileUssdMessagingReceiveMessage:
 ret = KReqModeRePostImmediately |
 KReqModeMultipleCompletionWithInterestLevel;
 break;
 // Services handled by TSY
-case EMobileUssdMessagingSendMessage:
+case EMobileUssdMessagingSendMessageDefaultHandler:
+	ret = KReqModeSessionBased | KReqModeTransferToDefaultHandler;
+	break;
+case EMobileUssdMessagingSendMessage:
 case EMobileUssdMessagingSendMessageNoFdnCheck:
 case EMobileUssdMessagingSendRelease:
-//ret = KReqModeSessionBased;
+ret = KReqModeSessionBased;
-ret = 0;
 break;
 case EMobileUssdMessagingNotifyNetworkRelease:
 // Multiple completion because the clients don't have to own the
 // session in order to be notified that the session has been
 // released.
-ret = KReqModeMultipleCompletionEnabled;
+ret = KReqModeRePostImmediately | KReqModeMultipleCompletionEnabled;
 break;
 default:
 User::Leave( KErrNotSupported );
 break;
 }
 	{
 	ret = KErrArgument;
 	}
 ReqCompleted( aTsyReqHandle, ret );
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 // CMmUssdTsy::ReceiveMessage
 //
 void CMmUssdTsy::CompleteReceiveMessage(
 TInt aError,
 	CMmDataPackage* aDataPackage )
 {
-// TODO if a session is in progress and this is a notification then we need to send back
-// a USSD busy code.
 TFLOGSTRING("TSY: CMmUssdTsy::CompleteReceiveMessage.\n" );
 TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle(
 EMultimodeUssdReceiveMessage );
 if ( ( EMultimodeUssdReqHandleUnknown != reqHandle ) )
 {
 // reset req handle. Returns the deleted req handle
 reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(
 EMultimodeUssdReceiveMessage );
 if ( KErrNone == aError )
 {
 TDes8* unpackedReceiveUssdMessagePtr = NULL;
 RMobileUssdMessaging::TMobileUssdAttributesV1* unpackedReceiveUssdMessageAttributesPtr = NULL;
 aDataPackage->UnPackData (&unpackedReceiveUssdMessagePtr, &unpackedReceiveUssdMessageAttributesPtr);
 if(iReceiveUssdMessagePtr->MaxLength() >= unpackedReceiveUssdMessagePtr->Length())
 	{
 				*iReceiveUssdMessagePtr = *unpackedReceiveUssdMessagePtr;
 				*iReceiveUssdMessageAttributesPtr = *unpackedReceiveUssdMessageAttributesPtr;
 {
 TFLOGSTRING2("TSY: CMmUssdTsy::SendMessage - Data length: %d", aData->Length() );
 TFLOGSTRING2("TSY: CMmUssdTsy::SendMessageL: iUssdNoFdnCheckFlag: %d", iUssdNoFdnCheckFlag);
 TInt ret = KErrNone;
 if ( iSsTransactionOngoing )
 	    {
 	    ret = KErrServerBusy;
 	    }
 else
 {
 // Send request to the Domestic OS layer.
 ret = iMmPhone->MessageManager()->HandleRequestL(
 EMobileUssdMessagingSendMessageNoFdnCheck, &package );
 }
 if ( iUssdNoFdnCheckFlag == EUssdNoFdnCheckNotUsed )
 {
 // Send request to the Domestic OS layer.
-ret = iMmPhone->MessageManager()->HandleRequestL(
+	if(EFalse == iSendToDefaultHandler)
-EMobileUssdMessagingSendMessage, &package );
+		{
-}
+		ret = iMmPhone->MessageManager()->HandleRequestL(
+				EMobileUssdMessagingSendMessage, &package );
+		}
+	else //default handler
+				{
+					ret = iMmPhone->MessageManager()->HandleRequestL(
+						EMobileUssdMessagingSendMessageDefaultHandler, &package );
+				}
+}
 iSsTransactionOngoing = ETrue;
 }
 if ( KErrNone != ret )
 {
 ReqCompleted( aTsyReqHandle, ret );
 iSsTransactionOngoing = EFalse;
 iUssdNoFdnCheckFlag = EUssdNoFdnCheckUnknown;
 }
 else
 	{
-/* TODO
 if (!IsSessionInProgress())
 {
 // If a session isn't in progress then reserve the session to
 // prevent any other attempts at opening a dialogue. If the send
 // succeeds then the session is opened. If the send fails or the
 // If the session is already in progress then no reservation is
 // necessary and the success or failure of this send does not
 // affect the session or dialogue state.
 (void)ReserveSession();
 }
-*/
 #ifdef REQHANDLE_TIMER
 // Check if NoFdnCheck is used or not
 if ( iUssdNoFdnCheckFlag == EUssdNoFdnCheckUsed )
 {
 // Set timer for the request
 SetTypeOfResponse( EMultimodeUssdSendMessageNoFdnCheck,
 aTsyReqHandle );
 }
-if ( iUssdNoFdnCheckFlag == EUssdNoFdnCheckNotUsed )
+if ( (iUssdNoFdnCheckFlag == EUssdNoFdnCheckNotUsed) &&
+	(EFalse == iSendToDefaultHandler))
 {
 // Set timer for the request
 SetTypeOfResponse( EMultimodeUssdSendMessage,
 aTsyReqHandle );
 }
+if ( (iUssdNoFdnCheckFlag == EUssdNoFdnCheckNotUsed) &&
+			(EFalse != iSendToDefaultHandler)) //send to default hadnler
+			   {
+			   // Set timer for the request
+			   SetTypeOfResponse( EMultimodeUssdSendMessageDefaultHandler,
+				   aTsyReqHandle );
+			   }
 #else
 // Check if NoFdnCheck is used or not
 if ( iUssdNoFdnCheckFlag == EUssdNoFdnCheckUsed )
 {
 // Save SendMessageNoFdnCheck request handle, set timer
 TInt CMmUssdTsy::SendMessageCancel(
 const TTsyReqHandle aTsyReqHandle )
 {
 // reset the req handle
 iTsyReqHandleStore->ResetTsyReqHandle( EMultimodeUssdSendMessage );
-//    CancelReserveSession(); TODO
+CancelReserveSession();
 // complete with cancel
 ReqCompleted( aTsyReqHandle, KErrCancel );
 iSsTransactionOngoing = EFalse;
 iUssdNoFdnCheckFlag = EUssdNoFdnCheckUnknown;
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
-// CMmUssdTsy::CompleteSendMessage
+// CmmUssdTsy::SendMessageCancelDefaultHandler
+// Cancels cancelling of USSD session.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+TInt CMmUssdTsy::SendMessageCancelDefaultHandler(
+const TTsyReqHandle aTsyReqHandle )
+{
+// reset the req handle
+iTsyReqHandleStore->ResetTsyReqHandle( EMultimodeUssdSendMessageDefaultHandler );
+CancelReserveSession();
+// complete with cancel
+ReqCompleted( aTsyReqHandle, KErrCancel );
+iSsTransactionOngoing = EFalse;
+iUssdNoFdnCheckFlag = EUssdNoFdnCheckUnknown;
+return KErrNone;
+}
+// ---------------------------------------------------------------------------
+// CMmUssdTsy::CompleteSendMessageDefaultHandler
 // Complete SendMessage
 // (other items were commented in a header).
 // ---------------------------------------------------------------------------
 //
-void CMmUssdTsy::CompleteSendMessage(
+void CMmUssdTsy::CompleteSendMessageDefaultHandler(
 TInt aError )
 {
 TFLOGSTRING("TSY: CMmUssdTsy::CompleteSendMessage.\n" );
 TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle(
-EMultimodeUssdSendMessage );
+/*EMultimodeUssdSendMessage*/EMultimodeUssdSendMessageDefaultHandler );
 if ( EMultimodeUssdReqHandleUnknown != reqHandle )
 {
 // reset req handle. Returns the deleted req handle
 reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(
-EMultimodeUssdSendMessage );
+		/*EMultimodeUssdSendMessage*/EMultimodeUssdSendMessageDefaultHandler );
-/* TODO
 // If the session is already in progress then no session management
 // action is required. Otherwise we either promote the reserved
 // session to an open session or cancel the reservation.
 if ( !IsSessionInProgress() && IsSessionReserved() )
 {
 else
 {
 CancelReserveSession();
 }
 }
-*/
 ReqCompleted( reqHandle, aError );
 iSsTransactionOngoing = EFalse;
 iUssdNoFdnCheckFlag = EUssdNoFdnCheckUnknown;
 }
 }
+// ---------------------------------------------------------------------------
+// CMmUssdTsy::CompleteSendMessage
+// Complete SendMessage
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CMmUssdTsy::CompleteSendMessage(
+TInt aError )
+{
+TFLOGSTRING("TSY: CMmUssdTsy::CompleteSendMessage.\n" );
+TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle(
+EMultimodeUssdSendMessage );
+if ( EMultimodeUssdReqHandleUnknown != reqHandle )
+{
+// reset req handle. Returns the deleted req handle
+reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(
+		EMultimodeUssdSendMessage );
+// If the session is already in progress then no session management
+// action is required. Otherwise we either promote the reserved
+// session to an open session or cancel the reservation.
+if ( !IsSessionInProgress() && IsSessionReserved() )
+{
+if ( KErrNone == aError )
+{
+SetSessionOwnerByTsyHandle( reqHandle );
+}
+else
+{
+CancelReserveSession();
+}
+}
+ReqCompleted( reqHandle, aError );
+iSsTransactionOngoing = EFalse;
+iUssdNoFdnCheckFlag = EUssdNoFdnCheckUnknown;
+}
+}
 // ---------------------------------------------------------------------------
 // CMmUssdTsy::SendReleaseL
 // This function cancels active ussd session asynchronously
 // (other items were commented in a header).
 //
 TInt CMmUssdTsy::SendReleaseL(
 const TTsyReqHandle aTsyReqHandle,
 TDes8* aReturnResult )
 {
-/* TODO
+	//Check if there is a session in progress
 if ( !IsSessionInProgress() )
 {
 // You can't release a dialogue that isn't in progress.
 return KErrDisconnected;
 }
-*/
 TTsyReqHandle sendReleaseHandle =
 iTsyReqHandleStore->GetTsyReqHandle( EMultimodeUssdSendRelease );
 if ( 0 < sendReleaseHandle )
 {
 // The request is already in processing because of previous request
 // Complete request with status value informing the client about
 // the situation.
-TFLOGSTRING("LTSY: CMmUssdTsy::SendRelease - KErrServerBusy");
+TFLOGSTRING("LTSY: CMmUssdTsy::SendRelease - KErrAccessDenied");
-ReqCompleted( aTsyReqHandle, KErrServerBusy );
+ReqCompleted( aTsyReqHandle, KErrAccessDenied );
 }
 else
 {
 TFLOGSTRING("TSY: CMmUssdTsy::SendRelease called");
 TInt ret = KErrGeneral;
 TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3>* ussdSendSSRequestPckg =
 reinterpret_cast< TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3>* >
 ( aReturnResult );
 if ( sizeof(RMobilePhone::TMobilePhoneSendSSRequestV3) >
 ussdSendSSRequestPckg->MaxLength() )
 {
 ret = KErrArgument;
 }
 // Send request to the Domestic OS layer.
 ret = iMmPhone->MessageManager()->HandleRequestL(
 EMobileUssdMessagingSendRelease );
 }
 // If ret is not KErrNone
 if ( KErrNone != ret )
 {
 ReqCompleted( aTsyReqHandle, ret );
 }
 else
 	{
 #ifdef REQHANDLE_TIMER
 // Set timer for the request
+			//If there is no session in progress this line lead to crash
 SetTypeOfResponse( EMultimodeUssdSendRelease, aTsyReqHandle );
 #else
 // Save SendMessage request handle, set timer
 iTsyReqHandleStore->SetTsyReqHandle(
 EMultimodeUssdSendRelease, aTsyReqHandle );
 #endif // REQHANDLE_TIMER
 	}
 }
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 // CMmUssdTsy::CompleteSendRelease
 {
 if ( KErrNone == aErrorCode )
 {
 aDataPackage->UnPackData ( *iReturnResultPtr );
 }
-//        EndSession();     TODO
+EndSession();
 ReqCompleted( reqHandle, aErrorCode );
 }
 }
 // ---------------------------------------------------------------------------
 const TTsyReqHandle aTsyReqHandle,
 TDes8* aMsgData,
 TDes8* aMsgAttributes) // aMsgAttributes may be NULL
 {
 TFLOGSTRING("TSY: CMmUssdTsy::NotifyNetworkRelease" );
+/*
+	//Check if there is a session in progress
+	if ( !IsSessionInProgress() )
+{
+// You can't release a dialogue that isn't in progress.
+return KErrDisconnected;
+}
+*/
 	if (aMsgData->MaxLength() < sizeof(RMobilePhone::TMobilePhoneSendSSRequestV3Pckg))
 		{
 	    TFLOGSTRING ("TSY: CMmNetTsy::NotifyNetworkRelease Bad size argument (arg1)");
 	    // Complete the request with appropiate error
 	    return KErrArgument;
 		}
 	if (aMsgAttributes &&
 		aMsgAttributes->MaxLength() < sizeof(RMobileUssdMessaging::TMobileUssdAttributesV1Pckg))
 		{
 	    TFLOGSTRING ("TSY: CMmNetTsy::NotifyNetworkRelease Bad size argument (arg2)");
 	    // Complete the request with appropiate error
 	    return KErrArgument;
 		}
 	TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3>* ussdSendSSRequestPckg =
 reinterpret_cast< TPckg<RMobilePhone::TMobilePhoneSendSSRequestV3>* >
 ( aMsgData );
 RMobilePhone::TMobilePhoneSendSSRequestV3& msgData =
 ( *ussdSendSSRequestPckg )();
 iReturnNotifyPtr = &msgData;
 if (aMsgAttributes != NULL)
 	{
 	    RMobileUssdMessaging::TMobileUssdAttributesV1Pckg* ussdAttributesPckg =
 	    		reinterpret_cast< RMobileUssdMessaging::TMobileUssdAttributesV1Pckg* > (aMsgAttributes);
 	    iReturnNotifyUssdMessageAttributesPtr = &msgAttributes;
 	}
 else
 	{
 	iReturnNotifyUssdMessageAttributesPtr = NULL;
 	}
 #ifdef REQHANDLE_TIMER
 // Set timer for the request
 SetTypeOfResponse( EMultimodeUssdNotifyNetworkRelease, aTsyReqHandle );
 #else
 // Save SendMessage request handle, set timer
 //
 void CMmUssdTsy::CompleteNotifyNetworkRelease(
 TInt aErrorCode,
 CMmDataPackage* aDataPackage )
 {
-//    EndSession(); TODO
+EndSession();
 TFLOGSTRING2("TSY: CMmUssdTsy::CompleteNotifyNetworkRelease. Error: %d", aErrorCode );
 // reset req handle. Returns the deleted req handle
 TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(
 		EMultimodeUssdNotifyNetworkRelease );
 iReceiveUssdMessagePtr = NULL;
 iReceiveUssdMessageAttributesPtr = NULL;
 iReturnResultPtr = NULL;
 iReturnNotifyPtr = NULL;
 iReturnNotifyUssdMessageAttributesPtr = NULL;
+iSendToDefaultHandler = EFalse;
 }
 #ifdef REQHANDLE_TIMER
 // ---------------------------------------------------------------------------
 // CMmUssdTsy::SetTypeOfResponse
 TInt timeOut( 0 );
 switch ( aReqHandleType )
 {
 case EMultimodeUssdSendMessage:
+case EMultimodeUssdSendMessageDefaultHandler:
 timeOut = KMmUssdSendMessageTimeOut;
 break;
 case EMultimodeUssdSendMessageNoFdnCheck:
 timeOut = KMmUssdSendMessageNoFdnCheckTimeOut;
 break;
 switch( aReqHandleType )
 {
 // Cases handled with automatic completion
 case EMultimodeUssdSendMessage:
 CompleteSendMessage( aError );
 break;
+case EMultimodeUssdSendMessageDefaultHandler:
+CompleteSendMessageDefaultHandler( aError );
+break;
 case EMultimodeUssdSendMessageNoFdnCheck:
 CompleteSendMessageNoFdnCheck( aError );
 break;
 case EMultimodeUssdSendRelease:
 returnResult.iOpCode = static_cast< TUint8 >( KErrTimedOut );
 {
 TBool isRequestPossible ( ETrue );
 switch ( aIpc )
 {
 case EMobileUssdMessagingSendMessage:
+case EMobileUssdMessagingSendMessageDefaultHandler:
 case EMobileUssdMessagingSendMessageNoFdnCheck:
 case EMobileUssdMessagingSendRelease:
 isRequestPossible = EFalse;
 break;
 case EMobileUssdMessagingReceiveMessage:

branch	opencode
changeset 77	930a53cdc2d3
parent 24	6638e7f4bd8f
child 78	d4cfc65049ba