1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 

    18 // INCLUDE FILES

    19 #include "cmmsmstsy.h"

    20 #include "cmmphonetsy.h"

    21 #include "cmmsmsstoragetsy.h"

    22 #include "cmmsmsgsmext.h"

    23 #include "cmmtsyreqhandlestore.h"

    24 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>

    25 #include "MmTsy_numberOfSlots.h"

    26 #include <ctsy/serviceapi/cmmsmsutility.h>

    27 #include "cmmsmssendrequest.h"

    28 #include <ctsy/serviceapi/mstktsysatservice.h>  

    29 #include "CMmCommonStaticUtility.h"

    30 #include <ctsy/serviceapi/gsmerror.h>

    31 #include <ctsy/pluginapi/cmmdatapackage.h>

    32 #include <etelsat.h>  // for Sat MO SM Control error values

    33 

    34 

    35 // ======== MEMBER FUNCTIONS ========

    36 

    37 CMmSmsTsy::CMmSmsTsy()

    38     {

    39 TFLOGSTRING("TSY: CMmSmsTsy::CMmSmsTsy: constructor");

    40     }

    41 

    42 void CMmSmsTsy::ConstructL()

    43     {

    44 TFLOGSTRING("TSY: CMmSmsTsy::ConstructL");

    45 #ifdef REQHANDLE_TIMER   

    46     //create req handle store

    47     iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, iMmPhone, 

    48         EMultimodeSmsMaxNumOfRequests, iSmsReqHandles );

    49 #else

    50     // create req handle store

    51     iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

    52         EMultimodeSmsMaxNumOfRequests, iSmsReqHandles );

    53 #endif // REQHANDLE_TIMER   

    54 

    55     // Reset all CMmSmsTsy variables

    56     ResetVariables();

    57 

    58     // SMS message array

    59     iSmsMsgArray = new ( ELeave ) CArrayPtrFlat<TSmsMsg>( 1 );

    60 

    61     // Create GSM mode SMS extension

    62     iMmSmsExtInterface = CMmSmsGsmExt::NewL();

    63 

    64 

    65     // register sms tsy in the message manager

    66     iMmPhone->MessageManager()->RegisterTsyObject( 

    67         CMmMessageManagerBase::ESmsMessagingTsy, this );

    68 

    69     // at startup, there is no pending Send request

    70     iSmsSendReq = NULL;

    71 

    72     // Initialise off-line/on-line mode variable with information

    73     // from PhoneTsy. After object construction, this information

    74     // will be updated using DOS indications.

    75     TRfStateInfo phoneRfInfo = iMmPhone->GetRfStateInfo();

    76     if ( ERfsStateInfoInactive == phoneRfInfo )

    77         {

    78         iIsOffline = ETrue;

    79         }

    80     else

    81         {

    82         iIsOffline = EFalse;

    83         }

    84 TFLOGSTRING2("TSY: CMmSmsTsy::ConstructL: iIsOffline has been initialised to %d", iIsOffline);

    85 

    86     // there's no pending ResumeSmsReception request at startup

    87     iResumeSmsReceptionPending = EFalse;

    88   

    89     // Initialization for sms NoFdnCheck

    90     iSmsNoFdnCheckFlag = ESmsNoFdnCheckUnknown;

    91     

    92     iExpectAckOrNack = 0;

    93     

    94     }

    95 

    96 CMmSmsTsy* CMmSmsTsy::NewL(

    97     CMmPhoneTsy* aMmPhone )

    98     {

    99     CMmSmsTsy* aMmSmsTsy = new ( ELeave ) CMmSmsTsy();

   100     CleanupClosePushL(*aMmSmsTsy);

   101     aMmSmsTsy->iMmPhone = aMmPhone;

   102     aMmSmsTsy->ConstructL();

   103     CleanupStack::Pop();

   104 

   105     return aMmSmsTsy;

   106     }

   107 

   108 CMmSmsTsy::~CMmSmsTsy()

   109     {

   110 TFLOGSTRING("TSY: CMmSmsTsy::~CMmSmsTsy");

   111     if ( iMmPhone )

   112         {

   113         // deregister tsy object from message manager

   114         iMmPhone->MessageManager()->DeregisterTsyObject(this);

   115 

   116         // Release the SMS routing from DOS to TSY.

   117         // Send request to the Domestic OS layer. Ignore if it leaves

   118         TInt trapError = KErrNone;

   119         TRAP( trapError, iMmPhone->MessageManager()->HandleRequestL( 

   120                 EMmTsyDeactivateSmsRouting ); );

   121         }

   122 

   123     // try to complete send sms message.

   124     if ( iTsySatMessaging )

   125         {

   126         iTsySatMessaging->CompleteSendSmsMessage( KErrAccessDenied );

   127         }

   128 

   129     if ( iTsyReqHandleStore )

   130         {

   131         delete iTsyReqHandleStore;

   132         iTsyReqHandleStore = NULL;

   133         }

   134 

   135     if ( iSmsMsgArray )

   136         {

   137         iSmsMsgArray->ResetAndDestroy();

   138         delete iSmsMsgArray;

   139         iSmsMsgArray = NULL;

   140         }

   141 

   142     // Delete extension object

   143     if ( iMmSmsExtInterface )

   144         {

   145         delete iMmSmsExtInterface;

   146         iMmSmsExtInterface = NULL;

   147         }

   148 

   149     if ( iMmPhone )

   150         {

   151         iMmPhone->SetSmsSession( NULL );

   152         iMmPhone = NULL;

   153         }

   154 

   155     if ( iSmsSendReq )

   156         {

   157         delete iSmsSendReq;

   158         iSmsSendReq = NULL;

   159         }

   160     

   161     if ( iSMSPClientId )

   162         {

   163         delete iSMSPClientId;

   164         iSMSPClientId = NULL;

   165         }

   166 

   167 	// set pointers to NULL

   168 	iMmSmsStorageTsy = NULL;

   169 	iTsySatMessaging = NULL;

   170 	iNotifyReceiveModeChangePtr = NULL;

   171 	iReceiveMessageParamsPtr = NULL;

   172 	iReceiveMessagePduPtr = NULL;

   173 	iNotifySmsBearerPtr = NULL;

   174 	iSendMessageMsgAttrPckgPtr = NULL;

   175 	iGetMessageStoreInfoPtr = NULL;

   176 	iStoreSmspBufferPtr = NULL;

   177     }

   178 

   179 // --------------------------------------------------------------------------- 

   180 // CMmSmsTsy::Init 

   181 // Initialisation method that is called from ETel Server

   182 // (other items were commented in a header).

   183 // --------------------------------------------------------------------------- 

   184 //

   185 void CMmSmsTsy::Init()

   186     {

   187     }

   188 

   189 // --------------------------------------------------------------------------- 

   190 // CMmSmsTsy::OpenNewObjectByNameL 

   191 // Creates new object and returns a pointer to it

   192 // (other items were commented in a header).

   193 // --------------------------------------------------------------------------- 

   194 //

   195 CTelObject* CMmSmsTsy::OpenNewObjectByNameL( 

   196     const TDesC& aName )

   197     {

   198     if ( aName.Compare( KETelIccSmsStore ) == KErrNone )

   199         {

   200         iMmSmsStorageTsy = CMmSmsStorageTsy::NewL( this, iMmPhone, 

   201             iMmSmsExtInterface, iTsyReqHandleStore );

   202         

   203         return iMmSmsStorageTsy;

   204         }

   205 

   206     // ME memory (KETelMeSmsStore) and combined memory (KETelCombinedSmsStore) 

   207     // are not supported

   208     User::Leave( KErrNotSupported );

   209     //lint -e{527} "unreachable code"

   210     

   211     return NULL;

   212     }

   213 

   214 // --------------------------------------------------------------------------- 

   215 // CMmSmsTsy::OpenNewObjectL 

   216 // Creates new object and returns a pointer to it

   217 // (other items were commented in a header).

   218 // --------------------------------------------------------------------------- 

   219 //

   220 CTelObject* CMmSmsTsy::OpenNewObjectL( 

   221     TDes& /*aNewName*/ )   

   222     {

   223     // Not supported

   224     User::Leave( KErrNotSupported );

   225     //lint -e{527} "unreachable code"

   226     

   227     return NULL;

   228     }

   229 

   230 // --------------------------------------------------------------------------- 

   231 // CMmSmsTsy::ExtFunc 

   232 // ExtFunc is called by the server when it has a "extended", 

   233 // i.e. non-core ETel request for the TSY. To process a request handle, 

   234 // request type and request data are passed to the TSY

   235 // (other items were commented in a header).

   236 // --------------------------------------------------------------------------- 

   237 //

   238 TInt CMmSmsTsy::ExtFunc(

   239     const TTsyReqHandle aTsyReqHandle, 

   240     const TInt aIpc, 

   241     const TDataPackage& aPackage )

   242     {

   243     TAny* dataPtr = aPackage.Ptr1();

   244     TInt ret( KErrNone );

   245 

   246     // before processing further the request, check if offline mode status

   247     // is enabled and if the given request can be perfomed in that case.

   248     if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() &&

   249         !IsRequestPossibleInOffline( aIpc ) )  

   250         {

   251 TFLOGSTRING2 ("TSY: Offline mode ON, request is not allowed: %d", aIpc );

   252         TInt error = CMmCommonStaticUtility::EpocErrorCode( KErrGeneral, 

   253                 KErrGsmOfflineOpNotAllowed );

   254 

   255         // Complete the request with appropiate error

   256         ReqCompleted ( aTsyReqHandle, error ); 

   257         }

   258     else

   259         {

   260         switch ( aIpc )

   261             {

   262             // SMS messaging requests that doesn't need trapping

   263             case EMobileSmsMessagingGetCaps:

   264                 ret = GetCaps( aTsyReqHandle, aPackage.Des1n() );

   265                 break;

   266             case EMobileSmsMessagingGetReceiveMode:

   267                 ret = GetReceiveMode( aTsyReqHandle, reinterpret_cast< 

   268 					RMobileSmsMessaging::TMobileSmsReceiveMode* >( dataPtr ) );

   269                 break;

   270             case EMobileSmsMessagingGetMoSmsBearer:

   271                 ret = GetMoSmsBearer( aTsyReqHandle, reinterpret_cast< 

   272                     RMobileSmsMessaging::TMobileSmsBearer* >( dataPtr) );

   273                 break;

   274             case EMobileSmsMessagingSetMoSmsBearer:

   275                 ret = SetMoSmsBearer( aTsyReqHandle, reinterpret_cast< 

   276                     RMobileSmsMessaging::TMobileSmsBearer*>( dataPtr) );

   277                 break;

   278             case EMobileSmsMessagingEnumerateMessageStores:

   279                 ret = EnumerateMessageStores( aTsyReqHandle, 

   280                     reinterpret_cast< TInt* >( dataPtr ) );

   281                 break;

   282             case EMobileSmsMessagingGetSmspListPhase2:

   283                 ret = ReadSmspListPhase2( aTsyReqHandle, reinterpret_cast< 

   284                     RMobilePhone::TClientId*>( dataPtr ), aPackage.Des2n() );

   285                 break;

   286             // SMS messaging requests that need trapping

   287             default:

   288                 // reset last tsy request type

   289                 iReqHandleType = EMultimodeSmsReqHandleUnknown; 

   290 

   291                 TInt leaveCode( KErrNone );

   292                 TRAP( leaveCode, ret = DoExtFuncL( aTsyReqHandle, aIpc, 

   293                     aPackage ); );

   294 

   295                 if ( KErrNone != leaveCode )

   296                     {

   297 TFLOGSTRING3("CMmSmsTsy: Leave trapped!, IPC=%d, error value:%d", aIpc, leaveCode );

   298                     ReqCompleted( aTsyReqHandle, leaveCode );

   299                     }

   300 

   301                 //save request handle

   302                 if ( EMultimodeSmsReqHandleUnknown != iReqHandleType )

   303                     {

   304 #ifdef REQHANDLE_TIMER

   305                     SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

   306 #else

   307                     //Never comes here. See SetTypeOfResponse.

   308                     iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, 

   309                         aTsyReqHandle );

   310 #endif // REQHANDLE_TIMER

   311                     }

   312                 break;

   313             }

   314         }

   315 

   316     return ret;

   317     }

   318 

   319 // --------------------------------------------------------------------------- 

   320 // CMmSmsTsy::DoExtFuncL 

   321 // DoExtFuncL calls messaging methods that can leave

   322 // (other items were commented in a header).

   323 // --------------------------------------------------------------------------- 

   324 //

   325 TInt CMmSmsTsy::DoExtFuncL(

   326     const TTsyReqHandle aTsyReqHandle, 

   327     const TInt aIpc, 

   328     const TDataPackage& aPackage )

   329     {

   330     TAny* dataPtr = aPackage.Ptr1();

   331     TAny* dataPtr2 = aPackage.Ptr2();

   332 

   333     TInt ret( KErrNone );

   334 

   335     switch ( aIpc )

   336         {

   337         // SMS messaging requests

   338         case EMobileSmsMessagingSetReceiveMode:

   339             ret = SetReceiveMode( aTsyReqHandle, reinterpret_cast<

   340 				RMobileSmsMessaging::TMobileSmsReceiveMode* >( dataPtr ) );

   341             break;

   342         case EMobileSmsMessagingNotifyReceiveModeChange:

   343             ret = NotifyReceiveModeChange( reinterpret_cast< 

   344                 RMobileSmsMessaging::TMobileSmsReceiveMode*>( dataPtr) );

   345             break;

   346         case EMobileSmsMessagingReceiveMessage:

   347             ret = ReceiveMessageL( aTsyReqHandle, aPackage.Des1n(), 

   348                 aPackage.Des2n() );

   349             break;

   350         case EMobileSmsMessagingAckSmsStored:

   351             ret = AckSmsStoredL( aTsyReqHandle, aPackage.Des1n(),

   352                 reinterpret_cast< TBool* >( dataPtr2 ) );

   353             break;

   354         case EMobileSmsMessagingNackSmsStored:

   355             ret = NackSmsStoredL( aTsyReqHandle, aPackage.Des1n(),

   356                 reinterpret_cast< TInt* >( dataPtr2 ) );

   357             break;

   358         case EMobileSmsMessagingResumeSmsReception:

   359             ret = ResumeSmsReceptionL( aTsyReqHandle );

   360             break;

   361         case EMobileSmsMessagingNotifyMoSmsBearerChange:

   362             ret = NotifyMoSmsBearerChange( reinterpret_cast< 

   363                 RMobileSmsMessaging::TMobileSmsBearer*> ( dataPtr ) );

   364             break;

   365         case EMobileSmsMessagingSendMessage:

   366             {

   367             iSmsNoFdnCheckFlag = ESmsNoFdnCheckNotUsed;

   368             ret = SendMessageL( aTsyReqHandle, aPackage.Des1n(),

   369                 aPackage.Des2n() );

   370             }

   371             break; 

   372         case EMobileSmsMessagingSendMessageNoFdnCheck:

   373             {

   374             iSmsNoFdnCheckFlag = ESmsNoFdnCheckUsed;

   375             ret = SendMessageL( aTsyReqHandle, aPackage.Des1n(),

   376                 aPackage.Des2n() );

   377             }

   378             break;

   379         case EMobileSmsMessagingGetMessageStoreInfo:

   380             ret = GetMessageStoreInfoL( aTsyReqHandle,

   381                 reinterpret_cast< TInt* >( dataPtr ), aPackage.Des2n() );

   382             break;

   383         case EMobileSmsMessagingGetSmspListPhase1:

   384             ret = ReadSmspListPhase1L( aTsyReqHandle,

   385                 reinterpret_cast< RMobilePhone::TClientId*>( dataPtr ),

   386                 reinterpret_cast< TInt* >( dataPtr2 ) );

   387             break;

   388         case EMobileSmsMessagingNotifySmspListChange:

   389             ret = NotifySmspListChange();

   390             break;

   391         case EMobileSmsMessagingStoreSmspList:

   392             ret = StoreSmspList( aTsyReqHandle, aPackage.Des1n() );

   393             break;

   394         default:

   395             ret = KErrNotSupported;

   396             break;

   397         }

   398 

   399     return ret;

   400     }

   401 

   402 // --------------------------------------------------------------------------- 

   403 // CMmSmsTsy::ReqModeL 

   404 // When the ETel server receives an "extension" client request, 

   405 // it will pass the IPC request number down to the TSY in order to find out 

   406 // what type of request it is

   407 // (other items were commented in a header).

   408 // --------------------------------------------------------------------------- 

   409 //

   410 CTelObject::TReqMode CMmSmsTsy::ReqModeL( 

   411     const TInt aIpc )     

   412     {

   413     CTelObject::TReqMode ret = 0;

   414     switch ( aIpc )

   415         {

   416         // Non-flow Controlled Services

   417         case EMobileSmsMessagingGetCaps:

   418         case EMobileSmsMessagingGetMoSmsBearer:

   419         case EMobileSmsMessagingSetMoSmsBearer:

   420         case EMobileSmsMessagingGetReceiveMode:

   421         case EMobileSmsMessagingEnumerateMessageStores:

   422         case EMobileSmsMessagingGetSmspListPhase2:

   423         case EMobileSmsMessagingAckSmsStored:

   424         case EMobileSmsMessagingNackSmsStored:

   425         case EMobileSmsMessagingSendMessage:

   426         case EMobileSmsMessagingSendMessageNoFdnCheck:

   427         case EMobileSmsMessagingResumeSmsReception:

   428         case EMobileSmsMessagingGetMessageStoreInfo:

   429         case EMobileSmsMessagingGetSmspListPhase1:

   430         case EMobileSmsMessagingStoreSmspList:

   431         case EMobileSmsMessagingSetReceiveMode:

   432             break;

   433         // Immediate Server Repost - but not multiple completion enabled

   434         case EMobileSmsMessagingReceiveMessage:

   435             ret = KReqModeRePostImmediately;

   436             break;

   437         // Multiple Completion Services with Immediate Server Repost

   438         case EMobileSmsMessagingNotifyReceiveModeChange:

   439         case EMobileSmsMessagingNotifyMoSmsBearerChange:

   440         case EMobileSmsMessagingNotifySmspListChange:

   441             ret = KReqModeMultipleCompletionEnabled | 

   442                 KReqModeRePostImmediately;

   443             break;

   444         default:

   445             User::Leave( KErrNotSupported );

   446             break;

   447         }

   448 

   449     return ret;

   450     }

   451 

   452 //---------------------------------------------------------------------------- 

   453 // CMmSmsTsy::NumberOfSlotsL 

   454 // When the ETel server discovers that a request is "repost 

   455 // immediately" it will ask the TSY how big a buffer it wants. 

   456 // NumberOfSlotsL Returns number of slots to be used for given requests

   457 // (other items were commented in a header).

   458 // --------------------------------------------------------------------------- 

   459 //

   460 TInt CMmSmsTsy::NumberOfSlotsL( 

   461     const TInt aIpc )     

   462     {

   463     TInt numberOfSlots = 1;

   464     switch ( aIpc )

   465         {

   466         case EMobileSmsMessagingReceiveMessage:

   467             numberOfSlots = KMmSmsMessagingReceiveMessageSlots;

   468             break; 

   469         // It is safer that normal notification trigger value is three

   470         // => Slotlimits are defined according to the requirements of

   471         // environment, five for messagereception and three for normal

   472         // notifications

   473         case EMobileSmsMessagingNotifyReceiveModeChange:

   474             numberOfSlots = KMmSmsMessagingNotifyReceiveModeChangeSlots;

   475             break; 

   476         case EMobileSmsMessagingNotifyMoSmsBearerChange:

   477             numberOfSlots = KMmSmsMessagingNotifyMoSmsBearerChangeSlots;

   478             break; 

   479         case EMobileSmsMessagingNotifySmspListChange:

   480             numberOfSlots = KMmSmsMessagingNotifySmspListChangeSlots;

   481             break; 

   482         default:

   483             User::Leave( KErrNotSupported );

   484             break;

   485         }

   486 

   487     return numberOfSlots;

   488     }

   489 

   490 //---------------------------------------------------------------------------- 

   491 // CMmSmsTsy::CancelService 

   492 // CancelService is called by the server when it is 

   493 // "cleaning-up" any still outstanding asynchronous requests before closing 

   494 // a client's sub-session. This will happen if a client closes its R-class 

   495 // handle without cancelling outstanding asynchronous requests on   

   496 // (other items were commented in a header).

   497 // --------------------------------------------------------------------------- 

   498 //

   499 TInt CMmSmsTsy::CancelService( 

   500     const TInt aIpc, 

   501     const TTsyReqHandle aTsyReqHandle )

   502     {

   503     TInt ret( KErrNone );

   504 

   505     switch ( aIpc )

   506         {

   507         case EMobileSmsMessagingSetReceiveMode:

   508             ret = SetReceiveModeCancel( aTsyReqHandle );

   509             break;

   510         case EMobileSmsMessagingNotifyReceiveModeChange:

   511             ret = NotifyReceiveModeChangeCancel( aTsyReqHandle );

   512             break;

   513         case EMobileSmsMessagingSetMoSmsBearer:

   514             ret = SetMoSmsBearerCancel( aTsyReqHandle );

   515             break;

   516         case EMobileSmsMessagingNotifyMoSmsBearerChange:

   517             ret = NotifyMoSmsBearerChangeCancel( aTsyReqHandle );

   518             break;

   519         case EMobileSmsMessagingGetMessageStoreInfo:

   520             ret = GetMessageStoreInfoCancel( aTsyReqHandle );

   521             break;

   522         case EMobileSmsMessagingGetSmspListPhase1:

   523         case EMobileSmsMessagingGetSmspListPhase2:

   524             ret = ReadAllSmspCancel( aTsyReqHandle );

   525             break;

   526         case EMobileSmsMessagingNotifySmspListChange:

   527             ret = NotifySmspListChangeCancel( aTsyReqHandle );

   528             break;

   529         case EMobileSmsMessagingSendMessage:

   530         case EMobileSmsMessagingAckSmsStored:

   531         case EMobileSmsMessagingNackSmsStored:

   532         case EMobileSmsMessagingResumeSmsReception:

   533         case EMobileSmsMessagingStoreSmspList:

   534             break;

   535         case EMobileSmsMessagingReceiveMessage:

   536             ret = ReceiveMessageCancel( aTsyReqHandle );

   537             break;

   538         case EMobileSmsMessagingSendMessageNoFdnCheck:

   539             ret = SendMessageNoFdnCheckCancel( aTsyReqHandle );

   540             break;

   541         default:

   542             ret = KErrGeneral; 

   543             break;

   544         } 

   545 

   546     return ret;

   547     }

   548 

   549 //---------------------------------------------------------------------------- 

   550 // CMmSmsTsy::RegisterNotification 

   551 // Called when the server recognises that this notification

   552 // is being posted for the first time on this sub-session object.It enables 

   553 // the TSY to "turn on" any regular notification messages that it may 

   554 // receive from DOS 

   555 // (other items were commented in a header).

   556 // --------------------------------------------------------------------------- 

   557 //

   558 TInt CMmSmsTsy::RegisterNotification( 

   559     const TInt aIpc )

   560     {

   561     TInt ret( KErrNotSupported );

   562 

   563     switch ( aIpc )

   564         {

   565         case EMobileSmsMessagingReceiveMessage:

   566         case EMobileSmsMessagingNotifyReceiveModeChange:

   567         case EMobileSmsMessagingNotifyMoSmsBearerChange:

   568         case EMobileSmsMessagingNotifySmspListChange:

   569             ret = KErrNone;

   570             break;

   571         default:

   572             ret = KErrNotSupported;

   573         }

   574 

   575     return ret;

   576     }

   577 

   578 //---------------------------------------------------------------------------- 

   579 // CMmSmsTsy::DeregisterNotification 

   580 // Called when the server recognises that this notification

   581 // will not be posted again because the last client to have 

   582 // a handle on this sub-session object has just closed the handle. 

   583 // It enables the TSY to "turn off" any regular notification messages that 

   584 // it may receive from the DOS

   585 // (other items were commented in a header).

   586 // --------------------------------------------------------------------------- 

   587 //

   588 TInt CMmSmsTsy::DeregisterNotification( 

   589     const TInt aIpc )

   590     {

   591     TInt ret( KErrNotSupported );

   592 

   593     switch ( aIpc )

   594         {

   595         case EMobileSmsMessagingReceiveMessage:

   596         case EMobileSmsMessagingNotifyReceiveModeChange:

   597         case EMobileSmsMessagingNotifyMoSmsBearerChange:

   598         case EMobileSmsMessagingNotifySmspListChange:

   599             ret = KErrNone;

   600             break;

   601         default:

   602             ret = KErrNotSupported;

   603         }

   604 

   605     return ret;

   606     }

   607 

   608 //---------------------------------------------------------------------------- 

   609 // CMmSmsTsy::GetCaps 

   610 // This method returns SMS messaging capabilities of the phone

   611 // (other items were commented in a header).

   612 // --------------------------------------------------------------------------- 

   613 //

   614 TInt CMmSmsTsy::GetCaps( 

   615     const TTsyReqHandle aTsyReqHandle, 

   616     TDes8* aCaps )

   617     {

   618     if(sizeof(RMobileSmsMessaging::TMobileSmsCapsV1) > aCaps->Size())

   619     	{

   620     	return KErrArgument;    	

   621     	}

   622     

   623     RMobileSmsMessaging::TMobileSmsCapsV1Pckg* smsCapsPckg =

   624         reinterpret_cast< RMobileSmsMessaging::TMobileSmsCapsV1Pckg* >( aCaps );

   625     RMobileSmsMessaging::TMobileSmsCapsV1& smsCaps = ( *smsCapsPckg )();

   626 

   627     // Capabilities depend on the TSY implementation.  

   628     smsCaps.iSmsMode = KSmsGsmModeCaps;

   629     smsCaps.iSmsControl = KSmsControlCaps;

   630 

   631     ReqCompleted( aTsyReqHandle, KErrNone );

   632 

   633     return KErrNone;

   634     }

   635 

   636 //---------------------------------------------------------------------------- 

   637 // CMmSmsTsy::GetReceiveMode 

   638 // This method retrieves the current setting of the TSY-phone 

   639 // incoming SMS receive mode

   640 // (other items were commented in a header).

   641 // --------------------------------------------------------------------------- 

   642 //

   643 TInt CMmSmsTsy::GetReceiveMode( 

   644     const TTsyReqHandle aTsyReqHandle, 

   645     RMobileSmsMessaging::TMobileSmsReceiveMode* aReceiveMode )

   646     {

   647     *aReceiveMode = iMobileSmsReceiveMode;

   648 

   649     ReqCompleted( aTsyReqHandle, KErrNone );

   650 

   651     return KErrNone;

   652     }

   653 

   654 //---------------------------------------------------------------------------- 

   655 // CMmSmsTsy::SetReceiveMode

   656 // This method sets the setting of the TSY-phone incoming SMS receive mode

   657 // (other items were commented in a header).

   658 // --------------------------------------------------------------------------- 

   659 //

   660 TInt CMmSmsTsy::SetReceiveMode( 

   661     const TTsyReqHandle aTsyReqHandle, 

   662     RMobileSmsMessaging::TMobileSmsReceiveMode const* aReceiveMode )

   663     {

   664     if ( RMobileSmsMessaging::EReceiveUnstoredClientAck == *aReceiveMode )

   665         {

   666         iMobileSmsReceiveMode = *aReceiveMode;

   667 

   668         CompleteNotifyReceiveModeChange();

   669 

   670         ReqCompleted( aTsyReqHandle, KErrNone );

   671         }

   672     else

   673         {

   674         // EReceiveModeUnspecified, EReceiveStored, EReceiveUnstoredPhoneAck &

   675         // EReceiveAny modes not supported because of CS functionality.

   676         ReqCompleted( aTsyReqHandle, KErrNotSupported );

   677         }

   678 

   679     return KErrNone;

   680     }

   681 

   682 //---------------------------------------------------------------------------- 

   683 // CMmSmsTsy::SetReceiveModeCancel 

   684 // This method is used to cancel the outstanding asynchronous 

   685 // SetReceiveMode request

   686 // (other items were commented in a header).

   687 // --------------------------------------------------------------------------- 

   688 //

   689 TInt CMmSmsTsy::SetReceiveModeCancel( 

   690     const TTsyReqHandle aTsyReqHandle ) 

   691     {

   692     ReqCompleted( aTsyReqHandle, KErrCancel );

   693 

   694     return KErrNone;

   695     }

   696 

   697 //---------------------------------------------------------------------------- 

   698 // CMmSmsTsy::NotifyReceiveModeChange 

   699 // This method is used to notify the client if there is a 

   700 // change to the receive mode setting

   701 // (other items were commented in a header).

   702 // --------------------------------------------------------------------------- 

   703 //

   704 TInt CMmSmsTsy::NotifyReceiveModeChange( 

   705     RMobileSmsMessaging::TMobileSmsReceiveMode* aReceiveMode )

   706     {

   707     iReqHandleType = EMultimodeSmsNotifyReceiveModeChange;

   708     iNotifyReceiveModeChangePtr = aReceiveMode;

   709 

   710     return KErrNone;

   711     }

   712 

   713 //---------------------------------------------------------------------------- 

   714 // CMmSmsTsy::NotifyReceiveModeChangeCancel 

   715 // This method cancel notify receive mode change request

   716 // (other items were commented in a header).

   717 // --------------------------------------------------------------------------- 

   718 //

   719 TInt CMmSmsTsy::NotifyReceiveModeChangeCancel( 

   720     const TTsyReqHandle aTsyReqHandle )

   721     {

   722     iTsyReqHandleStore->ResetTsyReqHandle( 

   723         EMultimodeSmsNotifyReceiveModeChange );

   724     ReqCompleted( aTsyReqHandle, KErrCancel );

   725     iNotifyReceiveModeChangePtr = NULL;

   726 

   727     return KErrNone;

   728     }

   729 

   730 //---------------------------------------------------------------------------- 

   731 // CMmSmsTsy::CompleteNotifyReceiveModeChange 

   732 // This method completes notify receive mode change request

   733 // (other items were commented in a header).

   734 // --------------------------------------------------------------------------- 

   735 //

   736 void CMmSmsTsy::CompleteNotifyReceiveModeChange()

   737     {

   738     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( 

   739         EMultimodeSmsNotifyReceiveModeChange );

   740 

   741     if ( reqHandle )

   742         {

   743         if ( iNotifyReceiveModeChangePtr )

   744 			{

   745 			*iNotifyReceiveModeChangePtr = iMobileSmsReceiveMode;

   746 			}

   747         ReqCompleted( reqHandle, KErrNone );

   748         iNotifyReceiveModeChangePtr = NULL;

   749         }

   750     }

   751 

   752 //---------------------------------------------------------------------------- 

   753 // CMmSmsTsy::ReceiveMessageL 

   754 // This method starts the reception of incoming unstored SMS

   755 // (other items were commented in a header).

   756 // --------------------------------------------------------------------------- 

   757 //

   758 TInt CMmSmsTsy::ReceiveMessageL( 

   759     const TTsyReqHandle aTsyReqHandle, 

   760     TDes8* aMsgData, 

   761     TDes8* aMsgAttributes )

   762     {

   763 TFLOGSTRING("TSY: CMmSmsTsy::ReceiveMessageL\n");

   764 	

   765 	if(sizeof(RMobileSmsMessaging::TMobileSmsReceiveAttributesV1) > aMsgAttributes->Size())

   766 		{

   767 		return KErrArgument;

   768 		}

   769 	

   770     iReceiveMessagePduPtr = aMsgData;

   771     iReceiveMessageParamsPtr = aMsgAttributes;

   772 

   773     if ( iMmPhone->IsModemStatusReady() )

   774         {

   775         // activate smsrouting only when modem status is ready        

   776         ActivateSmsRoutingL();

   777         }

   778  

   779     // Store request handle here. DeliverClass2ToSmsStack-method may complete

   780     // ReceiveMessage request

   781 #ifdef REQHANDLE_TIMER

   782     SetTypeOfResponse( EMultimodeSmsReceiveMessage, aTsyReqHandle );

   783 #else

   784     iTsyReqHandleStore->SetTsyReqHandle( 

   785         EMultimodeSmsReceiveMessage, aTsyReqHandle );

   786 #endif // REQHANDLE_TIMER

   787 

   788     // Check if there is class 2 messages waiting in TSY's internal memory.

   789     DeliverClass2ToSmsStack();

   790 

   791     return KErrNone;

   792     }

   793 

   794 //---------------------------------------------------------------------------- 

   795 // CMmSmsTsy::ReceiveMessageCancel 

   796 // This method cancels an MT message routing to the SMS

   797 // stack. TSY can not stop routing from SMS server because 

   798 // otherwise SMS server routes incoming messages to SIM server.

   799 // Negative acknowledgement is sent to the network if message

   800 // comes when SMS stack routing is not activated

   801 // (other items were commented in a header).

   802 // --------------------------------------------------------------------------- 

   803 //

   804 TInt CMmSmsTsy::ReceiveMessageCancel( 

   805     const TTsyReqHandle aTsyReqHandle )

   806     {

   807     iTsyReqHandleStore->ResetTsyReqHandle( EMultimodeSmsReceiveMessage );

   808 

   809     ReqCompleted( aTsyReqHandle, KErrCancel );

   810 

   811     return KErrNone;

   812     }

   813 

   814 //---------------------------------------------------------------------------- 

   815 // CMmSmsTsy::ActivateSmsRoutingL 

   816 // Activate SMS routing

   817 // (other items were commented in a header).

   818 // --------------------------------------------------------------------------- 

   819 //

   820 void CMmSmsTsy::ActivateSmsRoutingL()

   821     {

   822     if ( ( ERoutingNotActivated == iServerRoutingActivity ) || 

   823         ( ERoutingActivating == iServerRoutingActivity ) )

   824         {

   825         //Send request to the Domestic OS layer..

   826         User::LeaveIfError( iMmPhone->MessageManager()->HandleRequestL( 

   827             EMmTsyActivateSmsRouting ) );

   828         iServerRoutingActivity = ERoutingActivating;

   829         }    

   830     }

   831 

   832 //---------------------------------------------------------------------------- 

   833 // CMmSmsTsy::CompleteActivateSmsRouting

   834 // This method completes Activation of SMS routing

   835 // (other items were commented in a header).

   836 // --------------------------------------------------------------------------- 

   837 //

   838 void CMmSmsTsy::CompleteActivateSmsRouting( 

   839     TInt aError, 

   840     CMmDataPackage* aDataPackage )

   841     {

   842 	TUint8 aSmsRoutingStatus ( 0 );

   843 	aDataPackage->UnPackData( aSmsRoutingStatus ) ;

   844 

   845     if ( ( KErrNone == aError ) && 

   846         ( KSmsRoutingActivated == aSmsRoutingStatus ) )

   847         {

   848 TFLOGSTRING("TSY: CMmSmsTsy::CompleteActivateSmsRouting SMS routing activated");

   849         iServerRoutingActivity = ERoutingActivated;

   850         }

   851 	else if ( ( KErrNone == aError ) && 

   852 	    ( KSmsRoutingDeactivated == aSmsRoutingStatus ) )

   853 		{

   854 TFLOGSTRING("TSY: CMmSmsTsy::CompleteActivateSmsRouting SMS routing not activated");

   855         iServerRoutingActivity = ERoutingNotActivated;

   856 		}     

   857     else

   858         {

   859 TFLOGSTRING("TSY: CMmSmsTsy::CompleteActivateSmsRouting SMS routing activation failed");

   860         iServerRoutingActivity = ERoutingNotActivated;

   861 

   862         TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( 

   863             EMultimodeSmsReceiveMessage );

   864 

   865         if ( reqHandle )

   866             {

   867             ReqCompleted( reqHandle, aError );

   868             }

   869         }

   870     }

   871 

   872 //---------------------------------------------------------------------------- 

   873 // CMmSmsTsy::CompleteReceiveMessage 

   874 // This method completes reception of incoming unstored SMS

   875 // (other items were commented in a header).

   876 // --------------------------------------------------------------------------- 

   877 //

   878 void CMmSmsTsy::CompleteReceiveMessage( 

   879     TInt aError, 

   880     CMmDataPackage* aDataPackage )

   881     {   

   882     TInt ret( KErrNone );

   883     TBool smsInd( EFalse );

   884     TSmsMsg* smsMsg;

   885 

   886     TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle( 

   887         EMultimodeSmsReceiveMessage );

   888 

   889 TFLOGSTRING2("TSY: CMmSmsTsy::CompleteReceiveMessage. iClientStorageFull: %d", iClientStorageFull );

   890 

   891     // SMS successfully received

   892     if ( KErrNone == aError )

   893         {

   894         //unpack received data 

   895         aDataPackage->UnPackData( smsInd, smsMsg );

   896 

   897         // is the SMS a class2 SMS or not.

   898         TBool smsClass2 = smsMsg->iSmsClass2;

   899         

   900 		 // if store is not full, receive new class2 message and get 

   901          // notification

   902 		 if ( smsClass2 && ( 0 != smsMsg->iLocation ) && iMmSmsStorageTsy ) 

   903     		{

   904 TFLOGSTRING("TSY: CMmSmsTsy::CompleteReceiveMessage. CompleteNotifyStoreEvent happens");

   905 			iMmSmsStorageTsy->CMmSmsStorageTsy::CompleteNotifyStoreEvent(

   906 			smsMsg->iLocation, RMobilePhoneStore::KStoreEntryAdded	);

   907     		}

   908 

   909         // if SMS is a Class2 and SMS Memories are full and SIM SMS Memory 

   910         // not full

   911         if ( iClientStorageFull && smsClass2 )

   912             {

   913             if ( reqHandle )

   914                 {

   915                 // Store SMS in TSY's internal memory

   916                 TRAP( ret, StoreClass2MessageL( smsMsg ) );

   917 

   918                 // Message is not delivered to SMS Stack.Deliver message to 

   919                 // SMS. Stack after SMS Stack has called ReceiveMessage..

   920                 smsMsg->iDeleteAfterClientAck = EFalse;

   921             

   922 #ifdef USING_CTSY_DISPATCHER

   923                 CMmDataPackage package;

   924                 TDesC8* msgData = NULL;

   925                 package.PackData( &msgData );

   926 

   927 				// ignore if Acking fails

   928 				TRAP_IGNORE(

   929 							ret = iMmPhone->MessageManager()->HandleRequestL(EMobileSmsMessagingAckSmsStored, &package); 

   930 							);

   931                 iTsyReqHandleStore->ResetTsyReqHandle(EMultimodeSmsReceiveMessage);

   932                 ReqCompleted(reqHandle, aError);

   933 #else            

   934 				// ignore if Acking fails

   935 				TRAP_IGNORE( 

   936 					ret = iMmPhone->MessageManager()->HandleRequestL( 

   937 						EMobileSmsMessagingAckSmsStored );

   938 					);

   939 #endif //USING_CTSY_DISPATCHER			

   940                 }

   941             else

   942                 {

   943                 // Routing is activated, but SMS stack hasn't called 

   944                 // ReceiveMessage. Nack received message internally with cause 

   945                 // value "protocol error", otherwise SMS server releases 

   946                 // routings.

   947                 CMmDataPackage package;

   948                 TSmsMsg* nullSms = NULL;

   949                 TInt rpCause( KErrGsmSMSMemoryCapacityExceeded );

   950                 package.PackData( &nullSms, &rpCause );

   951 

   952 				// ignore if Nacking fails

   953 				TRAP_IGNORE( 

   954 					ret = iMmPhone->MessageManager()->HandleRequestL( 

   955 						EMobileSmsMessagingNackSmsStored, &package );

   956 					);

   957                 }

   958             }

   959         else 

   960             {

   961             // Class 0 or Class 1 or Class 2 message received.

   962             // This message has to be acknowledged to the network

   963             TInt rpError( KErrNone );

   964 

   965             if ( reqHandle && !iClientStorageFull )

   966                 {

   967                 // Deliver message to SMS stack

   968                 if(smsMsg->iSmsMsg.Length() > iReceiveMessagePduPtr->MaxLength())

   969                    	{

   970                    	ret = KErrArgument;

   971                    	}

   972                 else

   973                   	{

   974                    	ret = iMmSmsExtInterface->CompleteReceiveMessage( smsMsg,

   975 									iReceiveMessageParamsPtr, iReceiveMessagePduPtr );                	

   976                   	}

   977                 

   978                 iTsyReqHandleStore->ResetTsyReqHandle( 

   979                     EMultimodeSmsReceiveMessage );

   980 

   981 TFLOGSTRING("TSY: CMmSmsTsy::CompleteReceiveMessage. Deliver SMS to the SMS stack");

   982                 ReqCompleted( reqHandle, ret ); 

   983                 

   984                 // increase the count of expected acknowledgements

   985                 if(ret == KErrNone)

   986 					{

   987 					iExpectAckOrNack++;

   988 					}

   989                 }

   990             else

   991                 {

   992                 // Routing is activated, but SMS stack hasn't called 

   993                 // ReceiveMessage. Nack received message internally with cause 

   994                 // value "protocol error", otherwise SMS server releases 

   995                 // routings.

   996                 if (iClientStorageFull)

   997                     {

   998                     // SMS stack's memory is full. Nack message with error

   999                     // MemoryExceeded

  1000                     rpError = KErrGsmSMSMemoryCapacityExceeded;

  1001                     }

  1002                 else

  1003                     {

  1004                     rpError = KErrGsmSMSUnspecifiedProtocolError;

  1005                     }                

  1006                 }

  1007 

  1008             if ( KErrNone != rpError )

  1009                 {

  1010                 CMmDataPackage package;

  1011                 TSmsMsg* nullSms = NULL;

  1012                 package.PackData( &nullSms, &rpError );

  1013 

  1014 				// ignore if Nacking fails

  1015 				TRAP_IGNORE( 

  1016 					ret = iMmPhone->MessageManager()->HandleRequestL( 

  1017 						EMobileSmsMessagingNackSmsStored, &package );

  1018 					);

  1019                 }

  1020             }

  1021      

  1022         // end of successful SMS reception

  1023         }

  1024     // error in SMS reception

  1025     else

  1026         {

  1027         //unpack received data - only one parameter information is needed

  1028         aDataPackage->UnPackData( smsInd );

  1029 

  1030         // if SIM SMS Memory is full

  1031         if  ( ( KErrGsmSMSUnspecifiedProtocolError == aError ) && 

  1032             ( reqHandle ) )

  1033             {

  1034             // SMS Memories not full

  1035             if ( !iClientStorageFull )

  1036                 {

  1037                 CMmDataPackage package;

  1038                 TSmsMsg* nullSms = NULL;

  1039                 TInt rpCause( KErrGsmSMSUnspecifiedProtocolError );

  1040                 package.PackData( &nullSms, &rpCause );

  1041 

  1042 				// ignore if Nacking fails

  1043 				TRAPD( trapError,

  1044 					ret = iMmPhone->MessageManager()->HandleRequestL( 

  1045 					EMobileSmsMessagingNackSmsStored, &package ); );

  1046 				if (  KErrNone != trapError )

  1047 					{

  1048 					ret = trapError;

  1049 					}

  1050 TFLOGSTRING("TSY: CMmSmsTsy::CompleteReceiveMessage.KErrGsmSMSUnspecifiedProtocolError ");

  1051                 }

  1052             else // SMS Memory is full

  1053                 {

  1054                 CMmDataPackage package;

  1055                 TSmsMsg* nullSms = NULL;

  1056                 TInt rpCause( KErrGsmSMSMemoryCapacityExceeded );

  1057                 package.PackData( &nullSms, &rpCause );

  1058 

  1059 				// ignore if Nacking fails

  1060 				TRAPD( trapError,

  1061 					ret = iMmPhone->MessageManager()->HandleRequestL( 

  1062 						EMobileSmsMessagingNackSmsStored, &package ); );

  1063 				if (  KErrNone != trapError )

  1064 					{

  1065 					ret = trapError;

  1066 					}

  1067                 }

  1068             }

  1069         else if ( ( KErrGsmSMSMemoryCapacityExceeded == aError ) && 

  1070             ( reqHandle ) )

  1071             {

  1072             CMmDataPackage package;

  1073             TSmsMsg* nullSms = NULL;

  1074             TInt rpCause( KErrGsmSMSMemoryCapacityExceeded );

  1075             package.PackData( &nullSms, &rpCause );

  1076 

  1077 			// ignore if Nacking fails

  1078 			TRAPD( trapError,

  1079 				ret = iMmPhone->MessageManager()->HandleRequestL( 

  1080 					EMobileSmsMessagingNackSmsStored, &package );

  1081 				);

  1082 			if (  KErrNone != trapError )

  1083 				{

  1084 				ret = trapError;

  1085 				}

  1086 TFLOGSTRING("TSY: CMmSmsTsy::CompleteReceiveMessage.KErrGsmSMSMemoryCapacityExceeded ");

  1087             }

  1088         else if ( !reqHandle )

  1089             {

  1090             // Routing is activated, but SMS stack hasn't called 

  1091             // ReceiveMessage. Nack received message internally with cause 

  1092             // value "protocol error", otherwise SMS server releases 

  1093             // routings

  1094             CMmDataPackage package;

  1095             TSmsMsg* nullSms = NULL;

  1096             TInt rpCause;

  1097             if (iClientStorageFull)

  1098                 {

  1099                 rpCause = KErrGsmSMSMemoryCapacityExceeded;

  1100                 }

  1101             else

  1102                 {

  1103                 rpCause = KErrGsmSMSUnspecifiedProtocolError;

  1104                 }                

  1105             package.PackData( &nullSms, &rpCause );

  1106 

  1107 			// ignore if Nacking fails

  1108 			TRAPD( trapError,

  1109 				ret = iMmPhone->MessageManager()->HandleRequestL( 

  1110 					EMobileSmsMessagingNackSmsStored, &package );

  1111 				);

  1112 			if (  KErrNone != trapError )

  1113 				{

  1114 				ret = trapError;

  1115 				}

  1116             }

  1117         else if ( !smsInd ) 

  1118             {

  1119             // Error occurred while handling incoming message or acknowledging 

  1120             // received message

  1121             // Request handle exists (already checked above)

  1122             iTsyReqHandleStore->ResetTsyReqHandle( 

  1123                 EMultimodeSmsReceiveMessage );

  1124 

  1125             ReqCompleted( reqHandle, aError );

  1126 

  1127             // Incoming message handling failed. If client or TSY doesn't .

  1128             // ack incoming message, SMS Server may release all routings. 

  1129             // Set iSmsServerRoutingActivity to FALSE so client can activate 

  1130             // routings again.

  1131             iServerRoutingActivity = ERoutingNotActivated;

  1132             }

  1133 

  1134         if ( KErrNone != ret )