1 /*

     2 * Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Specific class for NWE tests

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include <e32svr.h>

    23 #include <stifparser.h>

    24 #include <stiftestinterface.h>

    25 #include <smsisi.h>

    26 #include "sms.h"

    27 

    28 

    29 // Converts semioct-code to character, semioctet can be 0x00 - 0x0F

    30 #define gsmSmsSemiOctetToChar( bcd )  gsmSmsSemiOctetToCharTable[bcd]

    31 

    32 // This table is used when a 03.40 or 04.11 address is converted to Unicode.

    33 const TUint gsmSmsSemiOctetToCharTable[16] =

    34    {

    35    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 0x00, 0x00, 0x00,

    36    0x00, 0x00, 0x00

    37    };

    38 

    39 

    40 // ============================ MEMBER FUNCTIONS ===============================

    41 // -----------------------------------------------------------------------------

    42 // CSMS::Delete

    43 // Delete here all resources allocated and opened from test methods.

    44 // Called from destructor.

    45 // -----------------------------------------------------------------------------

    46 //

    47 void CSMS::Delete()

    48     {

    49     iSmspListArray->ResetAndDestroy();

    50     }

    51 

    52 // -----------------------------------------------------------------------------

    53 // CSMS::RunMethodL

    54 // Run specified method. Contains also table of test mothods and their names.

    55 // -----------------------------------------------------------------------------

    56 //

    57 TInt CSMS::RunMethodL(

    58     CStifItemParser& aItem )

    59     {

    60     _LIT8 (KLog, "SMS: RunMethodL" );

    61     iSMSLog->Log((TDesC8)KLog);

    62     //iSMSLog->Log(_L("SMS: RunMethodL"));

    63     static TStifFunctionInfo const KFunctions[] =

    64         {

    65         // Copy this line for every implemented function.

    66         // First string is the function name used in TestScripter script file.

    67         // Second is the actual implementation member function.

    68         ENTRY( "RunIscTestCase", CCore::RunIscTestCase),

    69         ENTRY( "SyncIscTestCase", CCore::SyncIscTestCase),

    70         ENTRY( "RunIscTestCaseIgnoreXMLsWhenRealCellmoInUseFlagIsDefined",

    71                 CCore::RunIscTestCaseIgnoreXMLsWhenRealCellmoInUseFlagIsDefined),

    72         ENTRY( "SyncIscTestCaseDoNotSyncIfRealCellmoInUseFlagIsDefined",

    73                 CCore::SyncIscTestCaseDoNotSyncIfRealCellmoInUseFlagIsDefined),

    74         ENTRY( "SendSMSMessage", CSMS::SendSMSMessageL ),

    75         ENTRY( "SendTwoSMSMessages", CSMS::SendTwoSMSMessagesL ),

    76         ENTRY( "ReadSMSMessage", CSMS::ReadSMSMessageL ),

    77         ENTRY( "DeleteSMSMessage", CSMS::DeleteSMSMessageL ),

    78         ENTRY( "DeleteAllSMSMessages", CSMS::DeleteAllSMSMessagesL ),

    79         ENTRY( "SetMoSmsBearer", CSMS::SetMoSmsBearerL ),

    80         ENTRY( "WriteSMSMessage", CSMS::WriteSMSMessageL ),

    81         ENTRY( "ReceiveSMSMessage", CSMS::ReceiveSMSMessageL ),

    82         ENTRY( "ActivateSMSRouting", CSMS::ActivateSMSRoutingL ),

    83         ENTRY( "AckSMS", CSMS::AckSMSL ),

    84         ENTRY( "DeactivateSMSRouting", CSMS::DeactivateSMSRoutingL ),

    85         ENTRY( "ResumeSMS", CSMS::ResumeSMSL ),

    86         ENTRY( "ReadAllSMSMessage", CSMS::ReadAllSMSMessageL ),

    87         ENTRY( "NackSMS", CSMS::NackSMSL ),

    88         ENTRY( "SIMMsgStorageInfo", CSMS::SIMMsgStorageInfoL ),

    89         ENTRY( "ReadSmsParameters", CSMS::ReadSmsParametersL ),

    90         ENTRY( "StoreSmsParameters", CSMS::StoreSmsParametersL ),

    91         ENTRY( "SMSCacheInitialization", CSMS::SMSCacheInitializationL ),

    92         ENTRY( "HandleSpecifiedRequests", CCore::HandleSpecifiedRequests),

    93         ENTRY( "InitializeIPCRequestTable", CCore::InitializeIPCRequestTable),

    94         ENTRY( "SetExpectedCompleteIPC", CCore::SetExpectedCompleteIPC),

    95         ENTRY( "SetSmsParameterCheck", CSMS::SetSmsParameterCheck),

    96         ENTRY( "SetSmsReferenceParameters", CSMS::SetSmsReferenceParameters),

    97         ENTRY( "SmsSettingsUpdate", CSMS::SmsSettingsUpdate),

    98         };

    99 

   100     const TInt count = sizeof( KFunctions ) /

   101                         sizeof( TStifFunctionInfo );

   102 

   103     return RunInternalL( KFunctions, count, aItem );

   104 

   105     }

   106 

   107 // -----------------------------------------------------------------------------

   108 // CSMS::SetSmsParameterCheck

   109 // Sets SMS parameter checking and test case number

   110 // -----------------------------------------------------------------------------

   111 //

   112 TInt CSMS::SetSmsParameterCheck( CStifItemParser& aItem )

   113     {

   114     TInt ret( KErrNone );

   115     _LIT8(KSetSmsParameterCheck, "SMS::SetSmsParameterCheck");

   116     iSMSLog->Log((TDesC8)KSetSmsParameterCheck);

   117 

   118     // Is parameter checking required

   119     TPtrC string;

   120     aItem.GetNextString ( string );

   121 

   122     if ( _L("ON") == string )

   123         {

   124         iSmsParameterCheck = ETrue;

   125         }

   126     else

   127         {

   128         iSmsParameterCheck = EFalse;

   129         }

   130 

   131     // Test case number, used in parameter checking

   132     TInt testCaseNumber;

   133     aItem.GetNextInt( testCaseNumber );

   134     iTestCaseNumber = (TTestCase) testCaseNumber;

   135 

   136     return ret;

   137     }

   138 

   139 // -----------------------------------------------------------------------------

   140 // CSMS::SetSmsReferenceParameters

   141 // Sets SMS parameter checking and test case number

   142 // -----------------------------------------------------------------------------

   143 //

   144 TInt CSMS::SetSmsReferenceParameters( CStifItemParser& aItem )

   145     {

   146     TInt ret( KErrNone );

   147     _LIT8(KSetSmsReferenceParameters, "SMS::SetSmsReferenceParameters");

   148     iSMSLog->Log((TDesC8)KSetSmsReferenceParameters);

   149 

   150     // Set reference parameters depending on test case number

   151     if ( ETestCaseSms019 == iTestCaseNumber ||

   152          ETestCaseSms001 == iTestCaseNumber )

   153         {

   154         // Message reference

   155         TInt msgRef( 0 );

   156         aItem.GetNextInt( msgRef );

   157         iMsgRef = msgRef;

   158         // Length of the PDU string

   159         TInt count( 0 );

   160         aItem.GetNextInt( count );

   161 

   162         // PDU string

   163         TInt value( 0 );

   164         for ( TUint8 i( 0 ); i < count; i++ )

   165             {

   166             aItem.GetNextInt( value );

   167             iPdu.Append( value );

   168             }

   169         }

   170     else if ( ETestCaseSms008 == iTestCaseNumber )

   171         {

   172         TInt parameterIndicator;

   173         TInt protocolId;

   174         TInt dataCodingScheme;

   175         TInt validityPeriod;

   176         TPtrC destAddress;

   177         TPtrC serviceCenterAddress;

   178         TPtrC alphaTag;

   179 

   180         // Number of SMS parameter sets

   181         aItem.GetNextInt( iNumOfSmspSets );

   182 

   183         for ( TUint8 i( 0 ); i < iNumOfSmspSets; i++ )

   184             {

   185             TSmsParameters* smsParam = new ( ELeave ) TSmsParameters();

   186             aItem.GetNextInt( parameterIndicator );

   187             aItem.GetNextInt( protocolId );

   188             aItem.GetNextInt( dataCodingScheme );

   189             aItem.GetNextInt( validityPeriod );

   190             aItem.GetNextString( serviceCenterAddress );

   191             aItem.GetNextString( destAddress );

   192             aItem.GetNextString( alphaTag );

   193 

   194             smsParam->iParameterIndicator = parameterIndicator;

   195             smsParam->iProtocolId = protocolId;

   196             smsParam->iDataCodingScheme = dataCodingScheme;

   197             smsParam->iValidityPeriod = validityPeriod;

   198             smsParam->iServiceCenterAddress = serviceCenterAddress;

   199             smsParam->iDestinationAddress = destAddress;

   200             smsParam->iAlphaTagData = alphaTag;

   201 

   202             iSmspListArray->AppendL( smsParam );

   203             }

   204         }

   205 

   206     return ret;

   207     }

   208 

   209 // -----------------------------------------------------------------------------

   210 // CSMS::SmsSettingsUpdate

   211 // Update SMS route settings

   212 // -----------------------------------------------------------------------------

   213 //

   214 TInt CSMS::SmsSettingsUpdate( CStifItemParser& /*aItem*/ )

   215     {

   216     enum TMobileSmsBearer

   217         {

   218     /** SMS messages will only be sent over a packet-switched (GPRS) network. */

   219         ESmsBearerPacketOnly,

   220     /** SMS messages will only be sent over a circuit-switched (GSM) network. */

   221         ESmsBearerCircuitOnly,

   222     /** SMS messages will be sent over the packet-switched (GPRS) network if possible,

   223     otherwise over circuit-switched (GSM) network. */

   224         ESmsBearerPacketPreferred,

   225     /** SMS messages will be sent over the circuit-switched (GSM) network if possible,

   226     otherwise over packet-switched (GPRS) network. */

   227         ESmsBearerCircuitPreferred

   228         };

   229 

   230     TInt ret( KErrNone );

   231     _LIT8( KSmsSettingsUpdate, "SMS::SmsSettingsUpdate");

   232     iSMSLog->Log((TDesC8)KSmsSettingsUpdate);

   233 

   234     //Create package

   235     CMmDataPackage package;

   236     TMobileSmsBearer bearer( ESmsBearerPacketOnly );

   237     //Pack parameters

   238     package.PackData( &bearer );

   239 

   240     ret = HandleRequestL( EMobileSmsMessagingSetMoSmsBearer, &package );

   241     return ret;

   242     }

   243 

   244 // -----------------------------------------------------------------------------

   245 // CSMS::SendSMSMessage

   246 // SendSMSMessage method function.

   247 // -----------------------------------------------------------------------------

   248 //

   249 TInt CSMS::SendSMSMessageL(CStifItemParser& aItem)

   250     {

   251     _LIT8(KSendSMSMessage, "SMS::SendSMSMessage");

   252     iSMSLog->Log((TDesC8)KSendSMSMessage);

   253 

   254     TInt ret = KErrNotFound;

   255     TPtrC16  string;               // Name of the test case

   256     TPtrC  number;                 // Number of destination

   257     TPtrC  messagecenternumber;    // Number of MessageCenter

   258     TPtrC  satoriginated;          // SAT ORIGINATED SMS

   259     aItem.GetNextString(string);

   260     aItem.GetNextString(number);

   261     aItem.GetNextString(messagecenternumber);

   262     aItem.GetNextString(satoriginated);

   263 

   264     TBuf8 <260> msgdata;

   265     if (string == (_L("SendSMSMessage4")))

   266         {

   267         TUint MsgParameters( 0 );

   268         const TUint SmsMsgTypeSubmitOrSubmitR   = 0x01;

   269         const TUint SmsMsgVPabsolute            = 0x34;     // absolute format

   270 

   271         // TSY doesn't handle this information. Destination address goes in PDU.

   272         iMsgAttrib.iDestination.iTelNumber = number; //_L("0405431828");

   273         iMsgAttrib.iDestination.iTypeOfNumber = RMobilePhone::ENationalNumber;

   274         iMsgAttrib.iDestination.iNumberPlan = RMobilePhone::EIsdnNumberPlan;

   275         TBuf8<160> source;

   276         TUint8 UD[145]={'t','e','s','t',' ','m','e','s','s','a','g','e',' ',

   277             'f','o','u','r',' ','4',' ','*','*','*','*','*','*','*','*','*',

   278             '*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*',

   279             '*','*','*','*','*','*','*','*','*','*','*','*','*','*',

   280             '*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*',

   281             '*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*',

   282             '*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*',

   283             '*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*',

   284             '*','*','*','*','*','*','*','*','*','*','*',' ','l','e','n','g',

   285             't','h','=','1','4','9'};

   286 

   287         source.Append(&UD[0],sizeof(UD));

   288 

   289         // If you want to convert user data to 7bit format:

   290         TBuf8<140> UserData;

   291         TUint16 byte_count = (TUint16)source.Length();

   292         GsmLibCharConversion( TKGsmLibConvertToGsmFormat, source, byte_count );

   293         GsmLibSmsPackMessage( UserData, source, byte_count );

   294         TUint16 charCnt = (TUint16)( (UserData.Length()*8) / 7 );

   295         if ( ( ( ( iGsmMes.Length()*8 ) % 7 ) == 0) &&

   296             charCnt && charCnt <= iGsmMes.Length() )

   297             {

   298             if ( UserData[charCnt-1] == 0 )

   299             // if the last char is NULL, Actual charCnt is charCnt-1

   300                 {

   301                 charCnt--;

   302                 }

   303             }

   304 

   305         //CASE: SEND SMS MESSAGE

   306         iMsgAttrib.iFlags = (RMobileSmsMessaging::KSmsDataFormat +

   307                         RMobileSmsMessaging::KGsmServiceCentre +

   308                         RMobileSmsMessaging::KRemotePartyInfo +

   309                         RMobileSmsMessaging::KMoreToSend);

   310         // TSY takes now SC address from front of the TPDU

   311         iMsgAttrib.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu;

   312         iMsgAttrib.iGsmServiceCentre.iNumberPlan =

   313             RMobilePhone::EIsdnNumberPlan;

   314         iMsgAttrib.iGsmServiceCentre.iTypeOfNumber =

   315             RMobilePhone::EInternationalNumber;

   316 

   317         iMsgAttrib.iGsmServiceCentre.iTelNumber = messagecenternumber;

   318         iMsgAttrib.iMore = (TBool)(EFalse);

   319 

   320         MsgParameters = 0;

   321         MsgParameters |= SmsMsgTypeSubmitOrSubmitR;

   322         MsgParameters |= SmsMsgVPabsolute;

   323         TBuf8<7> ValidityPeriod;

   324         TUint8 validity[7]={0x00,0x00,0x00,0x00,0x00,0x00,0x00};

   325         ValidityPeriod.Append(&validity[0],sizeof(validity));

   326         TBuf<22> DEtemp = number;

   327         TPtrC16 DEnumber = DEtemp;

   328         TBuf8<12> DestinationAddress;

   329         GsmConvUnicodeTo0340Addr(

   330             2,   //TON national number

   331             1,   //NPI isdn numbering plan

   332             DestinationAddress,

   333             DEnumber );

   334         msgdata.SetLength(0);                   //reset buffer

   335         msgdata.Append(MsgParameters);          //Message params

   336         msgdata.Append(0x10);                   //TP-Message-Reference

   337         msgdata.Append(DestinationAddress);     //TP-Destination-Address

   338         msgdata.Append(0x00);                   //TP-Protocol-Identifier

   339         msgdata.Append(0x02);                   //TP-Data-Coding-Scheme (8bit)

   340         msgdata.Append(0xA7);                   //TP-Validity-Period

   341         msgdata.Append(charCnt);                //TP-User-Data-Length

   342         msgdata.Append(UserData);               //TP-User-Data

   343 

   344          //Create package

   345         CMmDataPackage package;

   346 

   347         //structure for all sms parameters and data

   348         TSendSmsDataAndAttributes sendData;

   349 

   350         sendData.iAttributes = &iMsgAttrib;

   351         sendData.iMsgData = &msgdata;

   352         if (satoriginated == (_L("SAT_ORIGINATED")))

   353             {

   354             sendData.iIpc = EMmTsySmsSendSatMessage;

   355             }

   356         else if (satoriginated == (_L("NO_FDN_CHECK")))

   357             {

   358             sendData.iIpc = EMobileSmsMessagingSendMessageNoFdnCheck;

   359             }

   360         else

   361             {

   362             sendData.iIpc = EMobileSmsMessagingSendMessage;

   363             }

   364         //Pack parameters

   365         package.PackData( &sendData );

   366 

   367         if (satoriginated == (_L("SAT_ORIGINATED")))

   368             {

   369             ret = HandleRequestL( EMmTsySmsSendSatMessage, &package );

   370             }

   371         else if (satoriginated == (_L("NO_FDN_CHECK")))

   372             {

   373             ret = HandleRequestL( EMobileSmsMessagingSendMessageNoFdnCheck, &package );

   374             }

   375         else

   376             {

   377             ret = HandleRequestL( EMobileSmsMessagingSendMessage, &package );

   378             }

   379 

   380         // Signal with return status if it is not KErrNone

   381         if ( KErrNone != ret )

   382             {

   383             Signal ( ret );

   384             ret = KErrNone;

   385             }

   386 

   387         if ( KErrNone == ret )

   388 

   389             {

   390             _LIT8( KSendOk, "Send SMS Message ok" );

   391             iSMSLog->Log((TDesC8)KSendOk );

   392             iSMSLog->Log( _L("Send SMS Message ok"));

   393             }

   394         else

   395             {

   396             _LIT8( KSendFailed, "Send SMS Message failed: %d" );

   397             iSMSLog->Log((TDesC8)KSendFailed, ret );

   398             }

   399         }

   400 

   401     else

   402         {

   403         ret = KErrNotFound;

   404         }

   405 

   406     return ret;

   407     }

   408 

   409 // -----------------------------------------------------------------------------

   410 // CSMS::CompleteSendSMSMessage

   411 // Complete SendSMSMessage method function.

   412 // -----------------------------------------------------------------------------

   413 //

   414 void CSMS::CompleteSendSMSMessage( TInt aResult ) //return Completion result value

   415     {

   416     _LIT8( KResult, "CompleteSendSMSMessage result: %d" );

   417     iSMSLog->Log((TDesC8)KResult, aResult );

   418 

   419     Signal( aResult );

   420     }

   421 

   422 // -----------------------------------------------------------------------------

   423 // CSMS::CompleteSendSMSMessage

   424 // Complete SendSMSMessage method function.

   425 // -----------------------------------------------------------------------------

   426 //

   427 void CSMS::CompleteSendSMSMessage( TInt aResult, CMmDataPackage* aDataPackage )

   428     {

   429     _LIT8( KResult, "CompleteSendSMSMessage result: %d" );

   430     iSMSLog->Log((TDesC8)KResult, aResult );

   431 

   432     // Check parameters depending on the test case

   433     if ( iSmsParameterCheck &&

   434         ( ETestCaseSms019 == iTestCaseNumber ||

   435         ETestCaseSms001 == iTestCaseNumber ) )

   436         {

   437         TUint16 msgRef( 0 );

   438         TBuf8<RMobileSmsMessaging::KGsmTpduSize> pdu;

   439         aDataPackage->UnPackData( msgRef, pdu );

   440 

   441         if ( msgRef != iMsgRef || pdu != iPdu )

   442             {

   443             aResult = KErrGeneral;

   444             }

   445         }

   446 

   447     iTestCaseNumber = ETestCaseNotDefined;

   448     Signal( aResult );

   449     }

   450 

   451 // -----------------------------------------------------------------------------

   452 // CSMS::SendTwoSMSMessages

   453 // SendTwoSMSMessages method function.

   454 // -----------------------------------------------------------------------------

   455 //

   456 TInt CSMS::SendTwoSMSMessagesL( CStifItemParser& aItem )

   457     {

   458     _LIT8(KSendSMSMessage, "SMS::SendTwoSMSMessages");

   459     iSMSLog->Log((TDesC8)KSendSMSMessage);

   460 

   461     TInt ret = KErrNotFound;

   462     TPtrC16  string;               // Name of the test case

   463     TPtrC  number;                 // Number of destination

   464     TPtrC  messagecenternumber;    // Number of MessageCenter

   465     aItem.GetNextString(string);

   466     aItem.GetNextString(number);

   467     aItem.GetNextString(messagecenternumber);

   468     TBuf8 <260> msgdata;

   469     if (string == (_L("SendTwoSMSMessage1")))

   470         {

   471         TUint MsgParameters( 0 );

   472         const TUint SmsMsgTypeSubmitOrSubmitR   = 0x01;

   473         const TUint SmsMsgVPabsolute            = 0x34;     // absolute format

   474 

   475 

   476         // TSY doesn't handle this information. Destination address goes in PDU.

   477         iMsgAttrib.iDestination.iTelNumber = number;

   478 

   479 

   480         iMsgAttrib.iDestination.iTypeOfNumber = RMobilePhone::ENationalNumber;

   481         iMsgAttrib.iDestination.iNumberPlan = RMobilePhone::EIsdnNumberPlan;

   482 

   483 

   484         TBuf8<160> source;

   485 

   486 

   487         if (iSecondMessage == EFalse)

   488             {

   489             TUint8 UD[35]=

   490                 {

   491                 'F','i','r','s','t',' ','m','e','s','s','a','g','e',

   492                 ' ','T','e','s','t',' ','S','e','n','d',' ','t','w','o',

   493                 ' ','m','e','s','s','a','g','e'

   494                 };

   495             source.Append(&UD[0],sizeof(UD));

   496             iSecondMessage = ETrue; // First message has been send

   497 

   498 

   499             //CASE: SEND SMS MESSAGE

   500             iMsgAttrib.iFlags = (RMobileSmsMessaging::KSmsDataFormat +

   501                             RMobileSmsMessaging::KGsmServiceCentre +

   502                             RMobileSmsMessaging::KRemotePartyInfo +

   503                             RMobileSmsMessaging::KMoreToSend);

   504 

   505             // TSY takes now SC address from front of the TPDU

   506             iMsgAttrib.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu;

   507             iMsgAttrib.iGsmServiceCentre.iNumberPlan =

   508                 RMobilePhone::EIsdnNumberPlan;

   509 

   510             iMsgAttrib.iGsmServiceCentre.iTypeOfNumber =

   511                 RMobilePhone::EInternationalNumber;

   512 

   513             iMsgAttrib.iGsmServiceCentre.iTelNumber = messagecenternumber;

   514             iMsgAttrib.iMore = (TBool)(EFalse);

   515 

   516             MsgParameters = 0;

   517             MsgParameters |= SmsMsgTypeSubmitOrSubmitR;

   518             MsgParameters |= SmsMsgVPabsolute;

   519 

   520             TBuf8<7> ValidityPeriod;

   521             TUint8 validity[7]={0x00,0x00,0x00,0x00,0x00,0x00,0x00};

   522             ValidityPeriod.Append(&validity[0],sizeof(validity));

   523             }

   524 

   525         else

   526             {

   527             TUint8 UD[36]=

   528                 {

   529                 'S','e','c','o','n','d',' ','m','e','s','s','a','g','e',

   530                 ' ','T','e','s','t',' ','S','e','n','d',' ','t','w','o',

   531                 ' ','m','e','s','s','a','g','e'

   532                 };

   533             source.Append(&UD[0],sizeof(UD));

   534 

   535 

   536             //CASE: SEND SMS MESSAGE

   537             iMsgAttrib.iFlags = (RMobileSmsMessaging::KSmsDataFormat +

   538                                  RMobileSmsMessaging::KGsmServiceCentre +

   539                                  RMobileSmsMessaging::KRemotePartyInfo +

   540                                  RMobileSmsMessaging::KMoreToSend);

   541 

   542             // TSY takes now SC address from front of the TPDU

   543             iMsgAttrib.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu;

   544             iMsgAttrib.iGsmServiceCentre.iNumberPlan =

   545                 RMobilePhone::EIsdnNumberPlan;

   546 

   547             iMsgAttrib.iGsmServiceCentre.iTypeOfNumber =

   548                 RMobilePhone::EInternationalNumber;

   549 

   550             iMsgAttrib.iGsmServiceCentre.iTelNumber = messagecenternumber;

   551             iMsgAttrib.iMore = (TBool)(EFalse);

   552             MsgParameters = 0;

   553             MsgParameters |= SmsMsgTypeSubmitOrSubmitR;

   554             MsgParameters |= SmsMsgVPabsolute;

   555 

   556             //TP-Status-Report-Request

   557             const TUint StatusReportRequested = 0x20; // binary 00100000

   558             MsgParameters |= StatusReportRequested;

   559             }

   560 

   561         TBuf8<140> UserData;

   562 

   563         TUint16 byte_count = (TUint16)source.Length();

   564         GsmLibCharConversion( TKGsmLibConvertToGsmFormat, source, byte_count );

   565         GsmLibSmsPackMessage( UserData, source, byte_count );

   566         TUint16 charCnt = (TUint16)( (UserData.Length()*8) / 7 );

   567 

   568         if ( ( ( ( iGsmMes.Length()*8 ) % 7 ) == 0) &&

   569             charCnt && charCnt <= iGsmMes.Length() )

   570             {

   571             if ( UserData[charCnt-1] == 0 )

   572             // if the last char is NULL, Actual charCnt is charCnt-1

   573                 {

   574                 charCnt--;

   575                 }

   576             }

   577 

   578         TBuf<22> DEtemp = number;//_L("0405431828");

   579         TPtrC16 DEnumber = DEtemp;

   580         TBuf8<12> DestinationAddress;

   581         GsmConvUnicodeTo0340Addr(

   582             2,   //TON national number

   583             1,   //NPI isdn numbering plan

   584             DestinationAddress,

   585             DEnumber );

   586 

   587         msgdata.SetLength(0);                   //reset buffer

   588         msgdata.Append(MsgParameters);          //Message params

   589         msgdata.Append(0x10);                   //TP-Message-Reference

   590         msgdata.Append(DestinationAddress);     //TP-Destination-Address

   591         msgdata.Append(0x00);                   //TP-Protocol-Identifier

   592         msgdata.Append(0x02);                   //TP-Data-Coding-Scheme (8bit)

   593         msgdata.Append(0xA7);                   //TP-Validity-Period

   594         msgdata.Append(charCnt);                //TP-User-Data-Length

   595         msgdata.Append(UserData);               //TP-User-Data

   596         // MO SMS bearer setting

   597         //Create package

   598         CMmDataPackage package;

   599 

   600         //structure for all sms parameters and data

   601         TSendSmsDataAndAttributes sendData;

   602 

   603         sendData.iAttributes = &iMsgAttrib;

   604         sendData.iMsgData = &msgdata;

   605         sendData.iIpc = EMobileSmsMessagingSendMessage;

   606 

   607         //Pack parameters

   608         package.PackData( &sendData );

   609 

   610         ret = HandleRequestL( EMobileSmsMessagingSendMessage, &package );

   611 

   612         if ( KErrNone == ret )

   613 

   614             {

   615             _LIT8( KSendOk, "Send SMS Message ok" );

   616             iSMSLog->Log((TDesC8)KSendOk );

   617             iSMSLog->Log( _L("Send SMS Message ok"));

   618             }

   619         else

   620             {

   621             _LIT8( KSendFailed, "Send SMS Message failed: %d" );

   622             iSMSLog->Log((TDesC8)KSendFailed, ret );

   623             }

   624         }

   625     else

   626         {

   627         ret = KErrNotFound;

   628         }

   629 

   630     return ret;

   631     }

   632 

   633 // -----------------------------------------------------------------------------

   634 // CSMS::ReadSMSMessage

   635 // Reading SMS message for slot

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

   637 //

   638 TInt CSMS::ReadSMSMessageL( CStifItemParser& aItem )

   639     {

   640     _LIT8(KReadSMSMessage, "SMS::ReadSMSMessage");

   641     iSMSLog->Log((TDesC8)KReadSMSMessage);

   642     TInt ret (KErrNotFound);

   643     TInt slot;

   644     TPtrC16 msgStatus;

   645     TPtrC16 numberingPlan;

   646     TPtrC16 typeOfNumber;

   647     TPtrC   serviceCentreAddress;

   648     TPtrC16 isClass2;

   649     TInt   tpdu;

   650 

   651     aItem.GetNextInt( slot );

   652     iSmsMsg.iLocation = slot;

   653 

   654     aItem.GetNextString( msgStatus );

   655     if ( msgStatus == ( _L("KSimSmsMtNotRead" ) ) )

   656         {

   657         iSmsMsg.iMessageStatus = KSimSmsMtNotRead;

   658         }

   659     else if ( msgStatus == ( _L("KSimSmsMtRead" ) ) )

   660         {

   661         iSmsMsg.iMessageStatus = KSimSmsMtRead;

   662         }

   663     else

   664         {

   665         iSmsMsg.iMessageStatus = KSimSmsNotPresent;

   666         }

   667 

   668     aItem.GetNextString( numberingPlan );

   669     if ( numberingPlan == ( _L("EIsdnNumberPlan" ) ) )

   670         {

   671         iSmsMsg.iMobileScNPI  = RMobilePhone::EIsdnNumberPlan;

   672         }

   673      else

   674         {

   675         iSmsMsg.iMobileScNPI  = RMobilePhone::EUnknownNumberingPlan;

   676         }

   677 

   678     aItem.GetNextString( typeOfNumber );

   679     if ( typeOfNumber == ( _L( "EInternationalNumber" ) ) )

   680         {

   681         iSmsMsg.iMobileScTON = RMobilePhone::EInternationalNumber;

   682         }

   683      else

   684         {

   685         iSmsMsg.iMobileScTON = RMobilePhone::EUnknownNumber;

   686         }

   687 

   688     aItem.GetNextString( serviceCentreAddress );

   689     iSmsMsg.iServiceCentre = serviceCentreAddress;

   690 

   691 

   692     iSmsMsg.iSmsClass2 = EFalse;

   693     aItem.GetNextString( isClass2 );

   694     if ( isClass2 == ( _L( "CLASS2" ) ) )

   695         {

   696         iSmsMsg.iSmsClass2 = ETrue;

   697         }

   698 

   699     while ( !aItem.GetNextInt( tpdu ) )

   700         {

   701         iSmsMsg.iSmsMsg.Append( tpdu );

   702         }

   703 

   704     CMmDataPackage package;

   705     package.PackData( &slot );

   706     ret= HandleRequestL( EMobilePhoneStoreRead, &package );

   707 

   708     if ( KErrNone == ret )

   709         {

   710         _LIT8( KOk, "Read SMS Message ok: %d" );

   711         iSMSLog->Log((TDesC8)KOk );

   712         }

   713     else

   714        {

   715        _LIT8( KFail, "Read SMS Message fails: %d" );

   716        iSMSLog->Log((TDesC8)KFail, ret );

   717        }

   718 

   719    return ret;

   720    }

   721 

   722 

   723 // -----------------------------------------------------------------------------

   724 // CSMS::CompleteReadSMSMessage

   725 // Complete ReadSMSMessage method function.

   726 // -----------------------------------------------------------------------------

   727 //

   728 void CSMS::CompleteReadSMSMessage(

   729     TInt aResult, //Completion result value

   730     CMmDataPackage* aDataPackage // pointer to DataPackage

   731     )

   732     {

   733     // checking results and unpacking message

   734     if ( KErrNone == aResult )

   735         {

   736         TSmsMsg smsMsg;

   737         aDataPackage->UnPackData( smsMsg );

   738         if ( ( smsMsg.iLocation != iSmsMsg.iLocation ) ||

   739              ( smsMsg.iMessageStatus != iSmsMsg.iMessageStatus ) ||

   740              ( smsMsg.iMobileScNPI != iSmsMsg.iMobileScNPI ) ||

   741              ( smsMsg.iMobileScTON != iSmsMsg.iMobileScTON ) ||

   742              ( smsMsg.iServiceCentre != iSmsMsg.iServiceCentre ) ||

   743              ( smsMsg.iSmsMsg != iSmsMsg.iSmsMsg ) ||

   744              ( smsMsg.iSmsClass2 != iSmsMsg.iSmsClass2 ) )

   745             {

   746             aResult = KErrGeneral;

   747             }

   748         }

   749 

   750     if ( KErrNone == aResult )

   751         {

   752         _LIT8( KOk, "Complete Read SMS Message ok: %d" );

   753         iSMSLog->Log((TDesC8)KOk );

   754         }

   755     else

   756         {

   757         _LIT8( KFail, "Compelte Read SMS Message Failed: %d" );

   758         iSMSLog->Log((TDesC8)KFail, aResult );

   759         }

   760 

   761     Signal( aResult );

   762 

   763     }

   764 

   765 // -----------------------------------------------------------------------------

   766 // CSMS::DeleteSMSMessage

   767 // Deletes SMS messages

   768 // -----------------------------------------------------------------------------

   769 //

   770 TInt CSMS::DeleteSMSMessageL( CStifItemParser& aItem )

   771     {

   772     _LIT8(KDeleteSMSMessage, "SMS::DeleteSMSMessage");

   773     iSMSLog->Log((TDesC8)KDeleteSMSMessage);

   774     TInt ret (KErrGeneral);

   775     TInt slot;

   776     aItem.GetNextInt(slot);

   777 

   778     CMmDataPackage package;

   779     package.PackData( &slot );

   780 

   781     ret= HandleRequestL( EMobilePhoneStoreDelete, &package );

   782 

   783     if ( KErrNone == ret )

   784         {

   785         _LIT8(KResultOk, "Delete SMS Message ok" );

   786         iSMSLog->Log((TDesC8)KResultOk);

   787         }

   788     else

   789         {

   790         _LIT8(KResultFail, "Delete SMS Message fails: %d" );

   791         iSMSLog->Log((TDesC8)KResultFail, ret );

   792         }

   793 

   794     return ret;

   795     }

   796 

   797 // -----------------------------------------------------------------------------

   798 // CSMS::CompleteDeleteSMSMessage

   799 // Complete DeleteSMSMessage method function.

   800 // -----------------------------------------------------------------------------

   801 //

   802 void CSMS::CompleteDeleteSMSMessage( TInt aResult ) //Completion result value

   803     {

   804     _LIT8(KResult, "Complete Delete SMS Message result: %d" );

   805     iSMSLog->Log((TDesC8)KResult, aResult );

   806 

   807     Signal( aResult );

   808     }

   809 

   810 

   811 // -----------------------------------------------------------------------------

   812 // CSMS::DeleteAllSMSMessages

   813 // Deletes all SMS messages

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

   815 // -----------------------------------------------------------------------------

   816 //

   817 TInt CSMS::DeleteAllSMSMessagesL( CStifItemParser& )

   818     {

   819     _LIT8(KDeleteAllSMSMessages, "SMS::DeleteAllSMSMessages");

   820     iSMSLog->Log((TDesC8)KDeleteAllSMSMessages);

   821     TInt ret (KErrGeneral);

   822 

   823     ret = HandleRequestL( EMobilePhoneStoreDeleteAll );

   824 

   825     if ( KErrNone == ret )

   826         {

   827         _LIT8(KResultOk, "Delete All SMS Messages ok" );

   828         iSMSLog->Log((TDesC8)KResultOk);

   829         }

   830     else

   831         {

   832         _LIT8(KResultFail, "Delete All SMS Messages fails: %d" );

   833         iSMSLog->Log((TDesC8)KResultFail, ret );

   834         }

   835 

   836     return ret;

   837     }

   838 

   839 // -----------------------------------------------------------------------------

   840 // CSMS::CompleteDeleteAllSMSMessages

   841 // Complete DeleteSMSMessage method function.

   842 // -----------------------------------------------------------------------------

   843 //

   844 void CSMS::CompleteDeleteAllSMSMessages( TInt aResult ) //Completion result value

   845     {

   846     _LIT8(KResult, "Complete Delete All SMS Messages result: %d" );

   847     iSMSLog->Log((TDesC8)KResult, aResult );

   848 

   849     Signal( aResult );

   850     }

   851 

   852 // -----------------------------------------------------------------------------

   853 // CSMS::SetMoSmsBearer

   854 // Sets MO SMS Bearer (packet data or GSM)

   855 // -----------------------------------------------------------------------------

   856 //

   857 TInt CSMS::SetMoSmsBearerL( CStifItemParser& aItem )

   858     {

   859     TInt ret (KErrGeneral);

   860 

   861     TInt bearerInt;

   862     aItem.GetNextInt(bearerInt);

   863 

   864     _LIT8(KSetMoSmsBearer, "SMS::SetMoSmsBearer, bearer=%d");

   865     iSMSLog->Log((TDesC8)KSetMoSmsBearer, bearerInt);

   866 

   867     RMobileSmsMessaging::TMobileSmsBearer bearer =

   868         static_cast< RMobileSmsMessaging::TMobileSmsBearer >( bearerInt );

   869 

   870     CMmDataPackage package;

   871     package.PackData( &bearer );

   872 

   873     ret = HandleRequestL( EMobileSmsMessagingSetMoSmsBearer, &package );

   874 

   875     if ( KErrNone == ret )

   876         {

   877         _LIT8(KResultOk, "Set MO SMS Bearer ok" );

   878         iSMSLog->Log((TDesC8)KResultOk);

   879         }

   880     else

   881         {

   882         _LIT8(KResultFail, "Set MO SMS Bearer fails: %d" );

   883         iSMSLog->Log((TDesC8)KResultFail, ret );

   884         }

   885 

   886     return ret;

   887     }

   888 

   889 // -----------------------------------------------------------------------------

   890 // CSMS::CompleteSetMoSmsBearer

   891 // Completes SetMoSmsBearer

   892 // -----------------------------------------------------------------------------

   893 //

   894 void CSMS::CompleteSetMoSmsBearer( TInt aResult ) //Completion result value

   895     {

   896     _LIT8(KResult, "Complete Set MO SMS Bearer result: %d" );

   897     iSMSLog->Log((TDesC8)KResult, aResult );

   898 

   899     Signal( aResult );

   900     }

   901 

   902 // -----------------------------------------------------------------------------

   903 // CSMS::WriteSMSMessage

   904 // Write message to qnted slot

   905 // -----------------------------------------------------------------------------

   906 //

   907 TInt CSMS::WriteSMSMessageL( CStifItemParser& aItem )

   908     {

   909     _LIT8(KWriteSMSMessage, "SMS::WriteSMSMessage");

   910     iSMSLog->Log((TDesC8)KWriteSMSMessage);

   911 

   912     TInt ret (KErrNotFound);

   913     TInt slot;

   914     TPtrC number;

   915     TPtrC servicecenternumber;

   916     aItem.GetNextString(number);

   917     aItem.GetNextString(servicecenternumber);

   918     aItem.GetNextInt(slot);

   919 

   920     // TName namee = _L( "SMS_SIM" );

   921     // TBuf8<12> serviceCenterAddress;

   922     TBuf8<12> destinationAddress;

   923     TBuf8<200> omaPDU;

   924 

   925     //TUint msgParameters( 0 );

   926     RMobileSmsStore::TMobileGsmSmsEntryV1 smsentry;

   927     RMobileSmsStore::TMobileGsmSmsEntryV1Pckg smsentryPckg( smsentry );

   928 

   929     TBuf8<7> validityperiod;

   930     TUint8 validity[7]={ 0x01,0x02,0x03,0x04,0x05,0x06,0x07 };

   931     validityperiod.Append(&validity[0],sizeof(validity));

   932 

   933     TUint MsgParameters( 0 );

   934     const TUint SmsMsgTypeSubmitOrSubmitR   = 0x01;

   935     const TUint SmsMsgVPabsolute            = 0x34;     // absolute format

   936 

   937     // TSY doesn't handle this information. Destination address goes in PDU.

   938     iMsgAttrib.iDestination.iTelNumber = number;

   939 

   940     iMsgAttrib.iDestination.iTypeOfNumber = RMobilePhone::ENationalNumber;

   941     iMsgAttrib.iDestination.iNumberPlan = RMobilePhone::EIsdnNumberPlan;

   942 

   943     TBuf8<160> source;

   944 

   945     if (-1 == slot)

   946         {

   947         TUint8 UD[145]={'t','e','s','t',' ','m','e','s','s','a','g','e',' ',

   948         'f','o','r',' ','S','M','S',' ','T','e','s','t',' ','C','a','s',

   949         'e',' ','T','C','-','S','M','S','-','0','1','6','b',' ','t','h',

   950         'i','s',' ','m','e','s','s','a','g','e',' ','i','s',' ',

   951         's','t','o','r','e','d',' ','i','n',' ','f','i','r','s','t',' ',

   952         'a','v','a','i','l','e','b','l','e',' ','s','l','o','t',' ','b',

   953         'y',' ','g','i','v','i','n','g',' ','s','l','o','t',' ','n','u',

   954         'm','b','e','r',' ','a','s',' ','-','1','*','*','*','*','*','*',

   955         '*','*','*','*','*','*','*','*','*','*','*',' ','l','e','n','g',

   956         't','h','=','1','4','9'};

   957         source.Append(&UD[0],sizeof(UD));

   958         }

   959     else

   960         {

   961         TUint8 UD[73]={'t','e','s','t',' ','m','e','s','s','a','g','e',' ',

   962         ' ','f','o','r',' ','t','e','s','t',' ','1','6','a',' ','i','n',

   963         'S','M','S',' ','T','e','s','t',' ','C','a','s','e','s',' ','*',

   964         'h','u','o','m','a','t','t','a','v','a','s','t','i',' ',

   965         '*','*','*','*',' ','L','e','n','g','t','h','=','7','5'};

   966         source.Append(&UD[0],sizeof(UD));

   967         }

   968 

   969     // If you want to convert user data to 7bit format:

   970     TBuf8<140> userdata;

   971     TUint16 byte_count = ( TUint16 )source.Length();

   972     GsmLibCharConversion(

   973         TKGsmLibConvertToGsmFormat, source, byte_count );

   974     GsmLibSmsPackMessage(

   975         userdata, source, byte_count );

   976 

   977     TBuf<23> detemp = number;

   978     TPtrC16 denumber = detemp;

   979     GsmConvUnicodeTo0340Addr(

   980         1,  //TON international number

   981         1,  //NPI isdn numbering plan

   982         destinationAddress,

   983         denumber );

   984 

   985     omaPDU.Append(0x24);                //Message params

   986     omaPDU.Append(destinationAddress);  //TP-Orginating Address

   987     omaPDU.Append(0x00);                //TP-Protocol-Identifier

   988     omaPDU.Append(0x00);                //TP-Data-Coding-Scheme

   989     omaPDU.Append(0x10);                //TP-Service Centre Time Stamp

   990     omaPDU.Append(0x80);                //TP-Service Centre Time Stamp

   991     omaPDU.Append(0x71);                //TP-Service Centre Time Stamp

   992     omaPDU.Append(0x41);                //TP-Service Centre Time Stamp

   993     omaPDU.Append(0x73);                //TP-Service Centre Time Stamp

   994     omaPDU.Append(0x14);                //TP-Service Centre Time Stamp

   995     omaPDU.Append(0x80);                //TP-Service Centre Time Stamp

   996     omaPDU.Append(byte_count);          //TP-User-Data-Length

   997     omaPDU.Append(userdata);            //TP-User-Data

   998 

   999     smsentry.iMsgData.Copy(omaPDU);

  1000 

  1001     smsentry.iMsgStatus = RMobileSmsStore::EStoredMessageRead;

  1002     smsentry.iIndex = slot;

  1003     smsentry.iServiceCentre.iNumberPlan = RMobilePhone::EIsdnNumberPlan;

  1004     smsentry.iServiceCentre.iTypeOfNumber = RMobilePhone::EInternationalNumber;

  1005     smsentry.iServiceCentre.iTelNumber = servicecenternumber;

  1006 

  1007     //Create package

  1008     CMmDataPackage package;

  1009 

  1010     RMobileSmsStore::TMobileGsmSmsEntryV1Pckg* smsentryPckgPtr = &smsentryPckg;

  1011 

  1012     //Pack parameters

  1013     package.PackData(&smsentryPckgPtr, &slot);

  1014 

  1015     ret = HandleRequestL( EMobilePhoneStoreWrite, &package );

  1016 

  1017     if ( KErrNone == ret )

  1018         {

  1019         _LIT8( KResultOk, "Write SMS Message ok" );

  1020         iSMSLog->Log((TDesC8)KResultOk );

  1021         iSMSLog->Log( _L("Write SMS Message ok"));

  1022         }

  1023     else

  1024         {

  1025         _LIT8( KResultFailed, "Write SMS Message failed: %d" );

  1026         iSMSLog->Log((TDesC8)KResultFailed, ret );

  1027         }

  1028 

  1029     return ret;

  1030     }

  1031 

  1032 // -----------------------------------------------------------------------------

  1033 // CSMS::CompleteWriteSMSMessage

  1034 // Complete WriteSMSMessage method function.

  1035 // -----------------------------------------------------------------------------

  1036 //

  1037 void CSMS::CompleteWriteSMSMessage(

  1038     TInt aResult, //Completion result value

  1039     CMmDataPackage* aDataPackage // pointer to DataPackage

  1040     )

  1041     {

  1042     // unpacking message

  1043     TSmsMsg* smsMsg;

  1044     aDataPackage->UnPackData( smsMsg );

  1045 

  1046     _LIT8(KResult, "Complete Write SMS Message: %d" );

  1047     iSMSLog->Log((TDesC8)KResult, aResult );

  1048 

  1049     Signal( aResult );

  1050     }

  1051 

  1052 

  1053 // -----------------------------------------------------------------------------

  1054 // CSMS::ReceiveMessage

  1055 // Cancels Receive Mode

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

  1057 // -----------------------------------------------------------------------------

  1058 //

  1059 TInt CSMS::ReceiveSMSMessageL( CStifItemParser& aItem )

  1060    {

  1061     _LIT8(KReceiveSMSMessages, "SMS::ReceiveSMSMessages");

  1062     TInt ret (KErrNone);

  1063 

  1064     // Save SMS class type for comparison when receivin is completed.

  1065     TPtrC string;

  1066     aItem.GetNextString ( string );

  1067 

  1068     // Set NetworkSelection

  1069     if ( _L("Class2") == string )

  1070         {

  1071         iSMSLog->Log( _L("Expect class 2 SMS") );

  1072         iReceivedSmsClass2 = ETrue;

  1073         }

  1074     else

  1075         {

  1076         iSMSLog->Log( _L("Expect class 1 SMS") );

  1077         iReceivedSmsClass2 = EFalse;

  1078         }

  1079 

  1080     if ( KErrNone == ret )

  1081         {

  1082         _LIT8( KResultOk, "Receive SMS Message ok" );

  1083         iSMSLog->Log((TDesC8)KResultOk );

  1084         iSMSLog->Log( _L("Receive SMS Message ok"));

  1085         }

  1086     else

  1087         {

  1088         _LIT8( KResultFailed, "Receive SMS Message failed: %d" );

  1089         iSMSLog->Log((TDesC8)KResultFailed, ret );

  1090         }

  1091 

  1092     return ret;

  1093     }

  1094 

  1095 

  1096 // -----------------------------------------------------------------------------

  1097 // CSMS::CompleteReceiveSMSMessage

  1098 // Complete Receive SMS Message method function.

  1099 // -----------------------------------------------------------------------------

  1100 //

  1101 void CSMS::CompleteReceiveSMSMessage(

  1102     TInt aResult, //Completion result value

  1103     CMmDataPackage* aDataPackage // pointer to DataPackage

  1104     )

  1105     {

  1106     _LIT8(KResult, "Complete Receive SMS Message result: %d" );

  1107     iSMSLog->Log((TDesC8)KResult, aResult );

  1108 

  1109     TBool smsInd;

  1110     TSmsMsg* smsMsg;

  1111     aDataPackage->UnPackData( smsInd, smsMsg );

  1112     // Is the SMS Class received the same as stored in ReceiveSMSMessageL

  1113     if ( smsMsg->iSmsClass2 != iReceivedSmsClass2 )

  1114         {

  1115         aResult = KErrGeneral;

  1116         }

  1117     Signal( aResult );

  1118     }

  1119 

  1120 

  1121 // -----------------------------------------------------------------------------

  1122 // CSMS::ActivateSMSRouting

  1123 // Activate SMS routing

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

  1125 // -----------------------------------------------------------------------------

  1126 //

  1127 TInt CSMS::ActivateSMSRoutingL( CStifItemParser& )

  1128     {

  1129     _LIT8(KActivateSMSRouting, "SMS::ActivateSMsRouting");

  1130     iSMSLog->Log((TDesC8)KActivateSMSRouting);

  1131     TInt ret (KErrNone);

  1132 

  1133     ret= HandleRequestL( EMmTsyActivateSmsRouting );

  1134