46 #include <net_modemisi.h>

    46 #include <net_modemisi.h>

    47 #include <smsisi.h>

    47 #include <smsisi.h>

    48 #include <ss_wmisi.h>

    48 #include <ss_wmisi.h>

    49 #include <tisi.h>

    49 #include <tisi.h>

    50 #include <uiccisi.h>

    50 #include <uiccisi.h>

    51 

    52 

    52 #include "OstTraceDefinitions.h"

    53 #include "OstTraceDefinitions.h"

    53 #ifdef OST_TRACE_COMPILER_IN_USE

    54 #ifdef OST_TRACE_COMPILER_IN_USE

    54 #include "cmmphonemesshandlerTraces.h"

    55 #include "cmmphonemesshandlerTraces.h"

    55 #endif

    56 #endif

   125 // --------------------------------------------------------------------------

   126 // --------------------------------------------------------------------------

   126 //

   127 //

   127 CMmPhoneMessHandler::CMmPhoneMessHandler()

   128 CMmPhoneMessHandler::CMmPhoneMessHandler()

   128     {

   129     {

   129 TFLOGSTRING("TSY: CMmPhoneMessHandler constructed.");

   130 TFLOGSTRING("TSY: CMmPhoneMessHandler constructed.");

   131 

   132 

   132     iACLIsProgress = EFalse;

   133     iACLIsProgress = EFalse;

   133     iAPNList = NULL;

   134     iAPNList = NULL;

   134     iAPNReadOrDeleteIndex = 0;

   135     iAPNReadOrDeleteIndex = 0;

   135     }

   136     }

   147         CMmSupplServMessHandler* aSupplServMessHandler,

   148         CMmSupplServMessHandler* aSupplServMessHandler,

   148         CMmUiccMessHandler* aUiccMessHandler

   149         CMmUiccMessHandler* aUiccMessHandler

   149         )

   150         )

   150     {

   151     {

   151 TFLOGSTRING("TSY: CMmPhoneMessHandler::NewL");

   152 TFLOGSTRING("TSY: CMmPhoneMessHandler::NewL");

   153 

   154 

   154     CMmPhoneMessHandler* phoneMessHandler =

   155     CMmPhoneMessHandler* phoneMessHandler =

   155         new ( ELeave ) CMmPhoneMessHandler();

   156         new ( ELeave ) CMmPhoneMessHandler();

   156 

   157 

   157     CleanupStack::PushL( phoneMessHandler );

   158     CleanupStack::PushL( phoneMessHandler );

   198         CMmSupplServMessHandler* aSupplServMessHandler,

   199         CMmSupplServMessHandler* aSupplServMessHandler,

   199         CMmUiccMessHandler* aUiccMessHandler

   200         CMmUiccMessHandler* aUiccMessHandler

   200         )

   201         )

   201     {

   202     {

   202 TFLOGSTRING("TSY: CMmPhoneMessHandler::ConstructL");

   203 TFLOGSTRING("TSY: CMmPhoneMessHandler::ConstructL");

   204 

   205 

   205     iPhoNetSender = aPhoNetSender;

   206     iPhoNetSender = aPhoNetSender;

   206     iSupplServMessHandler = aSupplServMessHandler;

   207     iSupplServMessHandler = aSupplServMessHandler;

   207     iMmUiccMessHandler = aUiccMessHandler;

   208     iMmUiccMessHandler = aUiccMessHandler;

   208     iMessageRouter = aMessageRouter;

   209     iMessageRouter = aMessageRouter;

   226 // --------------------------------------------------------------------------

   227 // --------------------------------------------------------------------------

   227 //

   228 //

   228 CMmPhoneMessHandler::~CMmPhoneMessHandler()

   229 CMmPhoneMessHandler::~CMmPhoneMessHandler()

   229     {

   230     {

   230 TFLOGSTRING("TSY: CMmPhoneMessHandler destructed.");

   231 TFLOGSTRING("TSY: CMmPhoneMessHandler destructed.");

   232 

   233 

   233     if( iStoreInfo )

   234     if( iStoreInfo )

   234         {

   235         {

   235         delete iStoreInfo;

   236         delete iStoreInfo;

   236         }

   237         }

   254 // --------------------------------------------------------------------------

   255 // --------------------------------------------------------------------------

   255 //

   256 //

   256 TInt CMmPhoneMessHandler::SubscribeEventsFromPhoNet()

   257 TInt CMmPhoneMessHandler::SubscribeEventsFromPhoNet()

   257     {

   258     {

   258 TFLOGSTRING("TSY: CMmPhoneMessHandler::SubscribeEventsFromPhoNet");

   259 TFLOGSTRING("TSY: CMmPhoneMessHandler::SubscribeEventsFromPhoNet");

   260 

   261 

   261     // Cross check requests with PhonetReceiver

   262     // Cross check requests with PhonetReceiver

   262     TUint8 requestArray[] = {

   263     TUint8 requestArray[] = {

   263 

   264 

   264         // CALL SERVER INDICATIONS

   265         // CALL SERVER INDICATIONS

   308         // SMS SERVER INDICATIONS

   309         // SMS SERVER INDICATIONS

   309             PN_SMS, SMS_RECEIVED_SIM_MSG_IND, // used only in SimAtkTSY

   310             PN_SMS, SMS_RECEIVED_SIM_MSG_IND, // used only in SimAtkTSY

   310             PN_SMS, SMS_RESOURCE_IND, // used only in SimAtkTSY

   311             PN_SMS, SMS_RESOURCE_IND, // used only in SimAtkTSY

   311             PN_SMS, SMS_RECEIVED_MSG_IND,

   312             PN_SMS, SMS_RECEIVED_MSG_IND,

   312             PN_SMS, SMS_CB_ROUTING_IND,

   313             PN_SMS, SMS_CB_ROUTING_IND,

   313 

   316 

   314         // UICC SERVER INDICATIONS

   317         // UICC SERVER INDICATIONS

   315             PN_UICC, UICC_CARD_IND,

   318             PN_UICC, UICC_CARD_IND,

   316             PN_UICC, UICC_IND,

   319             PN_UICC, UICC_IND,

   317             PN_UICC, UICC_REFRESH_IND,

   320             PN_UICC, UICC_REFRESH_IND,

   318 

   323 

   319 #ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

   324 #ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

   320         // MTC SERVER INDICATIONS

   325         // MTC SERVER INDICATIONS

   321             PN_MTC, MTC_STATE_INFO_IND,

   326             PN_MTC, MTC_STATE_INFO_IND,

   322 #else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

   327 #else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

   347         // PIPE SERVER INDICATIONS

   352         // PIPE SERVER INDICATIONS

   348 

   353 

   349         // GSS SERVER INDICATIONS

   354         // GSS SERVER INDICATIONS

   350             PN_GSS, GSS_HSXPA_USER_SETTING_IND,

   355             PN_GSS, GSS_HSXPA_USER_SETTING_IND,

   351 

   356 

   352         };

   360         };

   353 

   361 

   354     TInt ret = iPhoNetSender->SubscribeEvents(

   362     TInt ret = iPhoNetSender->SubscribeEvents(

   355         TPtr8( &requestArray[0],

   363         TPtr8( &requestArray[0],

   356             sizeof( requestArray ),

   364             sizeof( requestArray ),

   369         TInt aIpc,

   377         TInt aIpc,

   370         const CMmDataPackage* aDataPackage

   378         const CMmDataPackage* aDataPackage

   371         )

   379         )

   372     {

   380     {

   373 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ExtFuncL. Licensee specific implemtantion. IPC: %d", aIpc);

   381 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ExtFuncL. Licensee specific implemtantion. IPC: %d", aIpc);

   375 

   383 

   376     TInt ret( KErrNone );

   384     TInt ret( KErrNone );

   377     TUint8 transId( KPhoneTransId );

   385     TUint8 transId( KPhoneTransId );

   378 

   386 

   379     switch ( aIpc )

   387     switch ( aIpc )

   427             aDataPackage->UnPackData( readError );

   435             aDataPackage->UnPackData( readError );

   428 

   436 

   429             if ( ! readError )

   437             if ( ! readError )

   430                 {

   438                 {

   431 TFLOGSTRING("TSY: CMmPhoneMessHandler::ExtFuncL: commontsy refresh successfully completed ==> REFRESH_DONE");

   439 TFLOGSTRING("TSY: CMmPhoneMessHandler::ExtFuncL: commontsy refresh successfully completed ==> REFRESH_DONE");

   433                 ret = UiccRefreshReq( UICC_REFRESH_DONE );

   441                 ret = UiccRefreshReq( UICC_REFRESH_DONE );

   434                 }

   442                 }

   435             else

   443             else

   436                 {

   444                 {

   437 TFLOGSTRING("TSY: CMmPhoneMessHandler::ExtFuncL: commontsy refresh completed with an error ==> REFRESH_DONE");

   445 TFLOGSTRING("TSY: CMmPhoneMessHandler::ExtFuncL: commontsy refresh completed with an error ==> REFRESH_DONE");

   439                 ret = UiccRefreshReq( UICC_REFRESH_NOT_OK );

   447                 ret = UiccRefreshReq( UICC_REFRESH_NOT_OK );

   440                 }

   448                 }

   441             break;

   449             break;

   442             }

   450             }

   443 

   451 

   563             }

   571             }

   564 

   572 

   565         default:

   573         default:

   566             {

   574             {

   567 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ExtFuncL - Unknown IPC: %d", aIpc);

   575 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ExtFuncL - Unknown IPC: %d", aIpc);

   569             ret = KErrNotSupported;

   577             ret = KErrNotSupported;

   570             break;

   578             break;

   571             }

   579             }

   572         }

   580         }

   573 

   581 

   587     {

   595     {

   588     TInt resource( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );

   596     TInt resource( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );

   589     TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );

   597     TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );

   590 

   598 

   591 TFLOGSTRING3("TSY: CMmPhoneMessHandler::ReceiveMessageL, Resource: %d, Message: %d", resource, messageId );

   599 TFLOGSTRING3("TSY: CMmPhoneMessHandler::ReceiveMessageL, Resource: %d, Message: %d", resource, messageId );

   593 

   601 

   594     switch( resource )

   602     switch( resource )

   595         {

   603         {

   596 #ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

   604 #ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

   597         case PN_INFO:

   605         case PN_INFO:

   604                 InfoSerialNumberReadResp( aIsiMessage );

   612                 InfoSerialNumberReadResp( aIsiMessage );

   605                 }

   613                 }

   606             else

   614             else

   607                 {

   615                 {

   608 TFLOGSTRING("TSY: CMmPhoneMessHandler::ReceiveMessageL, switch resource - case PN_MODEM_INFO, switch messageId - default.\n" );

   616 TFLOGSTRING("TSY: CMmPhoneMessHandler::ReceiveMessageL, switch resource - case PN_MODEM_INFO, switch messageId - default.\n" );

   610                 }

   618                 }

   611             break; // end case PN_MODEM_INFO

   619             break; // end case PN_MODEM_INFO

   612             }

   620             }

   613         case PN_UICC:

   621         case PN_UICC:

   614             {

   622             {

   624             break;

   632             break;

   625             }

   633             }

   626        default:

   634        default:

   627             {

   635             {

   628 TFLOGSTRING("TSY: CMmPhoneMessHandler::ReceiveMessageL, switch resource - default.\n" );

   636 TFLOGSTRING("TSY: CMmPhoneMessHandler::ReceiveMessageL, switch resource - default.\n" );

   630             break;

   638             break;

   631             }

   639             }

   632         } // End of switch

   640         } // End of switch

   633     }

   641     }

   634 

   642 

   643         TUint8 aTransactionId,

   651         TUint8 aTransactionId,

   644         TUint8 aTarget // type of requested serial number

   652         TUint8 aTarget // type of requested serial number

   645         )

   653         )

   646     {

   654     {

   647 TFLOGSTRING("TSY: CMmPhoneMessHandler::InfoSerialNumberReadReq.");

   655 TFLOGSTRING("TSY: CMmPhoneMessHandler::InfoSerialNumberReadReq.");

   649 

   657 

   650     TBuf8<1> data;

   658     TBuf8<1> data;

   651     data.Append( aTarget ); // Target identifier ( INFO_SN_IMEI_PLAIN )

   659     data.Append( aTarget ); // Target identifier ( INFO_SN_IMEI_PLAIN )

   652 

   660 

   653     return iPhoNetSender->Send(

   661     return iPhoNetSender->Send(

   677 

   685 

   678     TUint8 status( aIsiMessage.Get8bit(

   686     TUint8 status( aIsiMessage.Get8bit(

   679         ISI_HEADER_SIZE + INFO_SERIAL_NUMBER_READ_RESP_OFFSET_STATUS ) );

   687         ISI_HEADER_SIZE + INFO_SERIAL_NUMBER_READ_RESP_OFFSET_STATUS ) );

   680 

   688 

   681 TFLOGSTRING2("TSY: CMmPhoneMessHandler::InfoSerialNumberReadResp, status=0x%02x",status);

   689 TFLOGSTRING2("TSY: CMmPhoneMessHandler::InfoSerialNumberReadResp, status=0x%02x",status);

   683 

   691 

   684     // Get information from possible sub block(s).

   692     // Get information from possible sub block(s).

   685     if ( INFO_OK == status )

   693     if ( INFO_OK == status )

   686         {

   694         {

   687         TBool subblockFound( EFalse );

   695         TBool subblockFound( EFalse );

   729 // --------------------------------------------------------------------------

   737 // --------------------------------------------------------------------------

   730 //

   738 //

   731 TInt CMmPhoneMessHandler::UiccReadDynamicFlagsReq()

   739 TInt CMmPhoneMessHandler::UiccReadDynamicFlagsReq()

   732     {

   740     {

   733 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadDynamicFlagsReq");

   741 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadDynamicFlagsReq");

   735 

   743 

   736     return UiccApplCmdReq(

   744     return UiccApplCmdReq(

   737         ETrIdReadDynamicFlags,

   745         ETrIdReadDynamicFlags,

   738         UICC_APPL_READ_TRANSPARENT,

   746         UICC_APPL_READ_TRANSPARENT,

   739         0,

   747         0,

   748 // --------------------------------------------------------------------------

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

   749 //

   757 //

   750 TInt CMmPhoneMessHandler::UiccWriteDynamicFlagsReq( TUint8 aInfo )

   758 TInt CMmPhoneMessHandler::UiccWriteDynamicFlagsReq( TUint8 aInfo )

   751     {

   759     {

   752 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccWriteDynamicFlagsReq");

   760 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccWriteDynamicFlagsReq");

   754 

   762 

   755     TInt ret( KErrNone );

   763     TInt ret( KErrNone );

   756     TUint8 line( 0 );

   764     TUint8 line( 0 );

   757 

   765 

   758     if ( RMobilePhone::EAlternateLinePrimary == aInfo )

   766     if ( RMobilePhone::EAlternateLinePrimary == aInfo )

   797 void CMmPhoneMessHandler::UiccReadDynamicFlagsResp(

   805 void CMmPhoneMessHandler::UiccReadDynamicFlagsResp(

   798     TInt aStatus,

   806     TInt aStatus,

   799     const TDesC8& aFileData )

   807     const TDesC8& aFileData )

   800     {

   808     {

   801 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadDynamicFlagsResp");

   809 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadDynamicFlagsResp");

   803 

   811 

   804     RMobilePhone::TMobilePhoneALSLine alsLine

   812     RMobilePhone::TMobilePhoneALSLine alsLine

   805         ( RMobilePhone::EAlternateLineUnknown );

   813         ( RMobilePhone::EAlternateLineUnknown );

   806 

   814 

   807     TInt ret( KErrNone );

   815     TInt ret( KErrNone );

   834 // --------------------------------------------------------------------------

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

   835 //

   843 //

   836 void CMmPhoneMessHandler::UiccWriteDynamicFlagsResp( TInt aStatus )

   844 void CMmPhoneMessHandler::UiccWriteDynamicFlagsResp( TInt aStatus )

   837     {

   845     {

   838 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccWriteDynamicFlagsResp");

   846 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccWriteDynamicFlagsResp");

   840 

   848 

   841     if ( UICC_STATUS_OK == aStatus )

   849     if ( UICC_STATUS_OK == aStatus )

   842         {

   850         {

   843         iSupplServMessHandler->SetVoiceCallForwardLine( iAlsLine );

   851         iSupplServMessHandler->SetVoiceCallForwardLine( iAlsLine );

   844         iMessageRouter->Complete( EMobilePhoneSetALSLine, KErrNone );

   852         iMessageRouter->Complete( EMobilePhoneSetALSLine, KErrNone );

   854 // Read CSP

   862 // Read CSP

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

   863 // --------------------------------------------------------------------------

   856 TInt CMmPhoneMessHandler::UiccCspFileReq()

   864 TInt CMmPhoneMessHandler::UiccCspFileReq()

   857     {

   865     {

   858 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccCspFileReq");

   866 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccCspFileReq");

   860 

   868 

   861     return UiccApplCmdReq(

   869     return UiccApplCmdReq(

   862         ETrIdReadCsp,

   870         ETrIdReadCsp,

   863         UICC_APPL_READ_TRANSPARENT,

   871         UICC_APPL_READ_TRANSPARENT,

   864         18,

   872         18,

   874 void CMmPhoneMessHandler::UiccCspFileResp(

   882 void CMmPhoneMessHandler::UiccCspFileResp(

   875     TInt aStatus,

   883     TInt aStatus,

   876     const TDesC8& aFileData )

   884     const TDesC8& aFileData )

   877     {

   885     {

   878 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccHandleCallFwdFlagsResp");

   886 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccHandleCallFwdFlagsResp");

   880 

   888 

   881     RMobilePhone::TMobilePhoneCspFileV1 cspFileEtel;

   889     RMobilePhone::TMobilePhoneCspFileV1 cspFileEtel;

   882 

   890 

   884         {

   893         {

   885         TUint8 i( 0 );

   894         TUint8 i( 0 );

   886         // Call offering capabilities

   895         // Call offering capabilities

   887         if ( KUiccCspCallOfferingCode == aFileData[i++] )

   896         if ( KUiccCspCallOfferingCode == aFileData[i++] )

   888             {

   897             {

   957 // --------------------------------------------------------------------------

   966 // --------------------------------------------------------------------------

   958 //

   967 //

   959 TInt CMmPhoneMessHandler::UiccImsiReq( )

   968 TInt CMmPhoneMessHandler::UiccImsiReq( )

   960     {

   969     {

   961 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccImsiReq");

   970 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccImsiReq");

   963 

   972 

   964     return UiccApplCmdReq(

   973     return UiccApplCmdReq(

   965         ETrIdReadImsi,

   974         ETrIdReadImsi,

   966         UICC_APPL_READ_TRANSPARENT,

   975         UICC_APPL_READ_TRANSPARENT,

   967         9,

   976         9,

   976 // --------------------------------------------------------------------------

   985 // --------------------------------------------------------------------------

   977 //

   986 //

   978 void CMmPhoneMessHandler::UiccImsiResp( TInt aStatus, const TDesC8& aFileData )

   987 void CMmPhoneMessHandler::UiccImsiResp( TInt aStatus, const TDesC8& aFileData )

   979     {

   988     {

   980 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccImsiResp" );

   989 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccImsiResp" );

   982 

   991 

   983     TInt err( KErrNone );

   992     TInt err( KErrNone );

   984     TBuf8<RMobilePhone::KIMSISize> imsiData;

   993     TBuf8<RMobilePhone::KIMSISize> imsiData;

   985 

   994 

   986     if ( ( UICC_STATUS_OK == aStatus ) &&

   995     if ( ( UICC_STATUS_OK == aStatus ) &&

   987          ( KImsiSize == aFileData.Length() ) )

   996          ( KImsiSize == aFileData.Length() ) )

   988         {

   997         {

   989         // 1st digit of the buffer is byte count (see 3GPP TS 51.011

   998         // 1st digit of the buffer is byte count (see 3GPP TS 51.011

   990         // 10.3.2 EFIMSI (IMSI)). Get first IMSI number from second byte higher

   999         // 10.3.2 EFIMSI (IMSI)). Get first IMSI number from second byte higher

   991         // nibbles. Lower part has parity information and it is ignored.

  1000         // nibbles. Lower part has parity information and it is ignored.

   993             ( ( aFileData[KFirstImsiDigit]>> KNibbleShift )&KNibbleMask ),

  1002             ( ( aFileData[KFirstImsiDigit]>> KNibbleShift )&KNibbleMask ),

   994             EDecimal );

  1003             EDecimal );

   995 

  1004 

   996         for( TUint8 i = KSecondImsiDigit;

  1005         for( TUint8 i = KSecondImsiDigit;

   997              i <= aFileData[KImsiStringByteCount];

  1006              i <= aFileData[KImsiStringByteCount];

  1007                 // Last digit found.

  1016                 // Last digit found.

  1008                 break;

  1017                 break;

  1009                 }

  1018                 }

  1010             if ( KUnusedNibble != ( ( aFileData[i]>>KNibbleShift )&KNibbleMask ) )

  1019             if ( KUnusedNibble != ( ( aFileData[i]>>KNibbleShift )&KNibbleMask ) )

  1011                 {

  1020                 {

  1013                     ( ( aFileData[i]>>KNibbleShift )&KNibbleMask ),

  1022                     ( ( aFileData[i]>>KNibbleShift )&KNibbleMask ),

  1014                     EDecimal );

  1023                     EDecimal );

  1015                 }

  1024                 }

  1016             else

  1025             else

  1017                 {

  1026                 {

  1041 // --------------------------------------------------------------------------

  1050 // --------------------------------------------------------------------------

  1042 //

  1051 //

  1043 TInt CMmPhoneMessHandler::UiccReadServiceProviderName()

  1052 TInt CMmPhoneMessHandler::UiccReadServiceProviderName()

  1044     {

  1053     {

  1045 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadServiceProviderName");

  1054 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadServiceProviderName");

  1047 

  1056 

  1048     return UiccApplCmdReq(

  1057     return UiccApplCmdReq(

  1049         ETrIdReadServiceProviderName,

  1058         ETrIdReadServiceProviderName,

  1050         UICC_APPL_READ_TRANSPARENT,

  1059         UICC_APPL_READ_TRANSPARENT,

  1051         17,

  1060         17,

  1062 void CMmPhoneMessHandler::UiccReadServiceProviderNameResp(

  1071 void CMmPhoneMessHandler::UiccReadServiceProviderNameResp(

  1063     TInt aStatus,

  1072     TInt aStatus,

  1064     const TDesC8& aFileData )

  1073     const TDesC8& aFileData )

  1065     {

  1074     {

  1066 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadServiceProviderNameResp");

  1075 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadServiceProviderNameResp");

  1068 

  1077 

  1069     TInt ret( KErrNotFound );

  1078     TInt ret( KErrNotFound );

  1071         {

  1081         {

  1072         // Store data and read SPN display info

  1082         // Store data and read SPN display info

  1073         ret = UiccProcessServiceTypeCheck( aFileData );

  1083         ret = UiccProcessServiceTypeCheck( aFileData );

  1074         }

  1084         }

  1075 

  1085 

  1077         {

  1087         {

  1078         // Complete error without data

  1088         // Complete error without data

  1079         iMessageRouter->Complete(

  1089         iMessageRouter->Complete(

  1080             EMobilePhoneGetServiceProviderName,

  1090             EMobilePhoneGetServiceProviderName,

  1081             KErrNotFound );

  1091             KErrNotFound );

  1092     TInt aStatus,

  1102     TInt aStatus,

  1093     TUint8 /*aDetails*/,

  1103     TUint8 /*aDetails*/,

  1094     const TDesC8& aFileData )

  1104     const TDesC8& aFileData )

  1095     {

  1105     {

  1096 TFLOGSTRING3("TSY: CMmPhoneMessHandler::ProcessUiccMsg, transaction ID: %d, status %d", aTraId, aStatus );

  1106 TFLOGSTRING3("TSY: CMmPhoneMessHandler::ProcessUiccMsg, transaction ID: %d, status %d", aTraId, aStatus );

  1098 

  1108 

  1099 switch( aTraId )

  1109 switch( aTraId )

  1100         {

  1110         {

  1101         case ETrIdReadImsi:

  1111         case ETrIdReadImsi:

  1102             {

  1112             {

  1155             break;

  1165             break;

  1156             }

  1166             }

  1157         default:

  1167         default:

  1158             {

  1168             {

  1159 TFLOGSTRING("TSY: CMmPhoneMessHandler::ProcessUiccMsg - unknown transaction ID" );

  1169 TFLOGSTRING("TSY: CMmPhoneMessHandler::ProcessUiccMsg - unknown transaction ID" );

  1161             break;

  1171             break;

  1162             }

  1172             }

  1163         }

  1173         }

  1164     return KErrNone;

  1174     return KErrNone;

  1165     }

  1175     }

  1171 //

  1181 //

  1172 TInt CMmPhoneMessHandler::UiccProcessServiceTypeCheck(

  1182 TInt CMmPhoneMessHandler::UiccProcessServiceTypeCheck(

  1173     const TDesC8& aFileData )

  1183     const TDesC8& aFileData )

  1174     {

  1184     {

  1175 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccProcessServiceTypeCheck");

  1185 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccProcessServiceTypeCheck");

  1177 

  1187 

  1178     TBuf8<KSpnFileSize> spnBuffer( aFileData.Mid( 1 ) );

  1188     TBuf8<KSpnFileSize> spnBuffer( aFileData.Mid( 1 ) );

  1179     TBuf8<KServiceProviderSize> spnOutputBuffer;

  1189     TBuf8<KServiceProviderSize> spnOutputBuffer;

  1180     CMmStaticUtility::ConvertGsmDataToUcs2(

  1190     CMmStaticUtility::ConvertGsmDataToUcs2(

  1181         spnBuffer,

  1191         spnBuffer,

  1240 void CMmPhoneMessHandler::UiccProcessSpnNameInfo(

  1250 void CMmPhoneMessHandler::UiccProcessSpnNameInfo(

  1241     TInt aStatus,

  1251     TInt aStatus,

  1242     const TDesC8& aFileData)

  1252     const TDesC8& aFileData)

  1243     {

  1253     {

  1244 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccProcessSpnNameInfo");

  1254 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccProcessSpnNameInfo");

  1246 

  1256 

  1247     TInt numOfPlmns( 0 );

  1257     TInt numOfPlmns( 0 );

  1248     TInt lengthOfDataInBytes( 0 );

  1258     TInt lengthOfDataInBytes( 0 );

  1249     TInt i( 0 ); // Index used of data extracting

  1259     TInt i( 0 ); // Index used of data extracting

  1251         {

  1261         {

  1252         TInt lengthOfLengthInBytes( 0 );

  1262         TInt lengthOfLengthInBytes( 0 );

  1253 

  1263 

  1254         // Display info is coded in TLV format in USIM.

  1264         // Display info is coded in TLV format in USIM.

  1255         if ( 0xA3 == aFileData[i] )

  1265         if ( 0xA3 == aFileData[i] )

  1303             aStatus = KErrGeneral;

  1313             aStatus = KErrGeneral;

  1304             }

  1314             }

  1305         }

  1315         }

  1306 

  1316 

  1307     // Copy PLMNs and complete

  1317     // Copy PLMNs and complete

  1309         {

  1319         {

  1310         if ( 170 < numOfPlmns )

  1320         if ( 170 < numOfPlmns )

  1311             {

  1321             {

  1312             numOfPlmns = 170;

  1322             numOfPlmns = 170;

  1313             }

  1323             }

  1352 // --------------------------------------------------------------------------

  1362 // --------------------------------------------------------------------------

  1353 //

  1363 //

  1354 void CMmPhoneMessHandler::UiccRefreshInd( const TIsiReceiveC &aIsiMessage )

  1364 void CMmPhoneMessHandler::UiccRefreshInd( const TIsiReceiveC &aIsiMessage )

  1355     {

  1365     {

  1356 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccRefreshInd");

  1366 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccRefreshInd");

  1358     TUint8 serviceType( aIsiMessage.Get8bit(

  1368     TUint8 serviceType( aIsiMessage.Get8bit(

  1359         ISI_HEADER_SIZE + UICC_REFRESH_IND_OFFSET_SERVICETYPE ) );

  1369         ISI_HEADER_SIZE + UICC_REFRESH_IND_OFFSET_SERVICETYPE ) );

  1360     if ( UICC_REFRESH_PERMISSION == serviceType )

  1370     if ( UICC_REFRESH_PERMISSION == serviceType )

  1361         {

  1371         {

  1362         UiccRefreshReq( UICC_REFRESH_OK );

  1372         UiccRefreshReq( UICC_REFRESH_OK );

  1373 // --------------------------------------------------------------------------

  1383 // --------------------------------------------------------------------------

  1374 //

  1384 //

  1375 void CMmPhoneMessHandler::UiccRefreshResp( const TIsiReceiveC &aIsiMessage )

  1385 void CMmPhoneMessHandler::UiccRefreshResp( const TIsiReceiveC &aIsiMessage )

  1376     {

  1386     {

  1377 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccRefreshResp");

  1387 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccRefreshResp");

  1379     if ( iCompleteRefresfDone )

  1389     if ( iCompleteRefresfDone )

  1380         {

  1390         {

  1381         TUint8 status( aIsiMessage.Get8bit(

  1391         TUint8 status( aIsiMessage.Get8bit(

  1382             ISI_HEADER_SIZE + UICC_REFRESH_RESP_OFFSET_STATUS ) );

  1392             ISI_HEADER_SIZE + UICC_REFRESH_RESP_OFFSET_STATUS ) );

  1383         TInt err( KErrNone );

  1393         TInt err( KErrNone );

  1396 // --------------------------------------------------------------------------

  1406 // --------------------------------------------------------------------------

  1397 //

  1407 //

  1398 TInt CMmPhoneMessHandler::UiccRefreshReq( TUint8 aStatus )

  1408 TInt CMmPhoneMessHandler::UiccRefreshReq( TUint8 aStatus )

  1399     {

  1409     {

  1400 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccRefreshReq");

  1410 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccRefreshReq");

  1402     TInt ret( KErrNone );

  1412     TInt ret( KErrNone );

  1403 

  1413 

  1404     // If there was error in cacheing some file, set internal flag

  1414     // If there was error in cacheing some file, set internal flag

  1405     if ( UICC_REFRESH_NOT_OK == aStatus )

  1415     if ( UICC_REFRESH_NOT_OK == aStatus )

  1406         {

  1416         {

  1449 // --------------------------------------------------------------------------

  1459 // --------------------------------------------------------------------------

  1450 //

  1460 //

  1451 void CMmPhoneMessHandler::HandleUiccRefresh( const TIsiReceiveC &aIsiMessage )

  1461 void CMmPhoneMessHandler::HandleUiccRefresh( const TIsiReceiveC &aIsiMessage )

  1452     {

  1462     {

  1453 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh" );

  1463 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh" );

  1455 

  1465 

  1456     TUint16 refreshFiles( 0 );

  1466     TUint16 refreshFiles( 0 );

  1457     TBool enabledServicesChanged( EFalse );

  1467     TBool enabledServicesChanged( EFalse );

  1458     TUint startIndex( ISI_HEADER_SIZE + SIZE_UICC_REFRESH_IND );

  1468     TUint startIndex( ISI_HEADER_SIZE + SIZE_UICC_REFRESH_IND );

  1459 

  1469 

  1475         switch( fileId )

  1485         switch( fileId )

  1476             {

  1486             {

  1477             case KElemFileSmsParams: // 6F42, SMS parameters

  1487             case KElemFileSmsParams: // 6F42, SMS parameters

  1478                 {

  1488                 {

  1479 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: SMSP refresh.");

  1489 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: SMSP refresh.");

  1481                 refreshFiles |= KCacheSmsParams;

  1491                 refreshFiles |= KCacheSmsParams;

  1482                 break;

  1492                 break;

  1483                 }

  1493                 }

  1484             case KElemFileFixedDiallingNumbers: // 6F3B, Storage FDN

  1494             case KElemFileFixedDiallingNumbers: // 6F3B, Storage FDN

  1485                 {

  1495                 {

  1486 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: FDN refresh");

  1496 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: FDN refresh");

  1488                 refreshFiles |= KCacheFdn;

  1498                 refreshFiles |= KCacheFdn;

  1489                 break;

  1499                 break;

  1490                 }

  1500                 }

  1491             case KElemSimServiceTable: // 6F38, Service table

  1501             case KElemSimServiceTable: // 6F38, Service table

  1492                 {

  1502                 {

  1493 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: ServiceTable refresh");

  1503 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: ServiceTable refresh");

  1495                 refreshFiles |= KCacheServiceTable;

  1505                 refreshFiles |= KCacheServiceTable;

  1496                 // Also internal service table cacheing is needed. EFalse means

  1506                 // Also internal service table cacheing is needed. EFalse means

  1497                 // no complete to CTSY.

  1507                 // no complete to CTSY.

  1498                 iInternalRefreshFiles |= KRefreshServiceTable;

  1508                 iInternalRefreshFiles |= KRefreshServiceTable;

  1499                 iMmUiccMessHandler->InitializeSimServiceTableCache( EFalse );

  1509                 iMmUiccMessHandler->InitializeSimServiceTableCache( EFalse );

  1500                 break;

  1510                 break;

  1501                 }

  1511                 }

  1502             case KElemFileDynFlagsOrange: // 6F9F, ALS

  1512             case KElemFileDynFlagsOrange: // 6F9F, ALS

  1503                 {

  1513                 {

  1504 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: ALS line refresh");

  1514 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: ALS line refresh");

  1506                 refreshFiles |= KCacheALSline;

  1516                 refreshFiles |= KCacheALSline;

  1507                 break;

  1517                 break;

  1508                 }

  1518                 }

  1509             case KElemFileShortMessages: // 6F3C, SMS

  1519             case KElemFileShortMessages: // 6F3C, SMS

  1510                 {

  1520                 {

  1511 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: SMS refresh");

  1521 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: SMS refresh");

  1513                 iInternalRefreshFiles |= KRefreshSms;

  1523                 iInternalRefreshFiles |= KRefreshSms;

  1514                 iMessageRouter->GetSmsMessHandler()->InitializeSmsCache();

  1524                 iMessageRouter->GetSmsMessHandler()->InitializeSmsCache();

  1515                 break;

  1525                 break;

  1516                 }

  1526                 }

  1517             case KElemFileAcl: // 6F57, ACL

  1527             case KElemFileAcl: // 6F57, ACL

  1518                 {

  1528                 {

  1519 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: APN refresh");

  1529 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: APN refresh");

  1521                 iMessageRouter->Complete(

  1531                 iMessageRouter->Complete(

  1522                     EMobilePhoneNotifyAPNListChanged,

  1532                     EMobilePhoneNotifyAPNListChanged,

  1523                     KErrNone );

  1533                     KErrNone );

  1524 

  1534 

  1525                 if ( iAPNList )

  1535                 if ( iAPNList )

  1531                 break;

  1541                 break;

  1532                 }

  1542                 }

  1533             case KElemEst: // 6F56, Enabled service table

  1543             case KElemEst: // 6F56, Enabled service table

  1534                 {

  1544                 {

  1535 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: ServiceTable enabled");

  1545 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: ServiceTable enabled");

  1537                 enabledServicesChanged = ETrue;

  1547                 enabledServicesChanged = ETrue;

  1538                 break;

  1548                 break;

  1539                 }

  1549                 }

  1540             case KElemFileCallFwdFlagsCphs:

  1550             case KElemFileCallFwdFlagsCphs:

  1541             case KElemFileCallFwdIndicationStatus:

  1551             case KElemFileCallFwdIndicationStatus:

  1542                 {

  1552                 {

  1543 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: Call forwarding flags refresh ");

  1553 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: Call forwarding flags refresh ");

  1545                 // Re-read call forwarding flags

  1555                 // Re-read call forwarding flags

  1546                 iInternalRefreshFiles |= KRefreshCallForwardingFlags;

  1556                 iInternalRefreshFiles |= KRefreshCallForwardingFlags;

  1547 

  1557 

  1548                 iMessageRouter->GetSupplServHandler()->ExtFuncL(

  1558                 iMessageRouter->GetSupplServHandler()->ExtFuncL(

  1549                     ECustomNotifyIccCallForwardingStatusChangeIPC,

  1559                     ECustomNotifyIccCallForwardingStatusChangeIPC,

  1551                 break;

  1561                 break;

  1552                 }

  1562                 }

  1553             case KElemFileOpl: // 6FC6, Operator PLMN List

  1563             case KElemFileOpl: // 6FC6, Operator PLMN List

  1554                 {

  1564                 {

  1555 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: OPL list refresh");

  1565 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: OPL list refresh");

  1557 

  1567 

  1558                 iInternalRefreshFiles |= KRefreshOplRules;

  1568                 iInternalRefreshFiles |= KRefreshOplRules;

  1559 

  1569 

  1560                 iMessageRouter->

  1570                 iMessageRouter->

  1561                     GetNetMessHandler()->

  1571                     GetNetMessHandler()->

  1564                 break;

  1574                 break;

  1565                 }

  1575                 }

  1566             case KElemFilePlmnNetworkName: // 6FC5, PLMN Network Name

  1576             case KElemFilePlmnNetworkName: // 6FC5, PLMN Network Name

  1567                 {

  1577                 {

  1568 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: PNN refresh");

  1578 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: PNN refresh");

  1570 

  1580 

  1571                 iInternalRefreshFiles |= KRefreshPnnRecord;

  1581                 iInternalRefreshFiles |= KRefreshPnnRecord;

  1572 

  1582 

  1573                 // Get PNN record to be cached.

  1583                 // Get PNN record to be cached.

  1574                 TUint8 pnnIdentifier(

  1584                 TUint8 pnnIdentifier(

  1584                 break;

  1594                 break;

  1585                 }

  1595                 }

  1586             case KElemFileOperatorName: // 6F14, Operator name

  1596             case KElemFileOperatorName: // 6F14, Operator name

  1587                 {

  1597                 {

  1588 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: ONS name refresh");

  1598 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: ONS name refresh");

  1590 

  1600 

  1591                 iInternalRefreshFiles |= KRefreshOnsName;

  1601                 iInternalRefreshFiles |= KRefreshOnsName;

  1592 

  1602 

  1593                 iMessageRouter->

  1603                 iMessageRouter->

  1594                     GetNetMessHandler()->

  1604                     GetNetMessHandler()->

  1597                 break;

  1607                 break;

  1598                 }

  1608                 }

  1599             default:

  1609             default:

  1600                 {

  1610                 {

  1601 TFLOGSTRING2("TSY:CMmPhoneMessHandler::HandleUiccRefresh:Unknown type: 0x%x", fileId);

  1611 TFLOGSTRING2("TSY:CMmPhoneMessHandler::HandleUiccRefresh:Unknown type: 0x%x", fileId);

  1603                 break;

  1613                 break;

  1604                 }

  1614                 }

  1605             }

  1615             }

  1606 

  1616 

  1607         // Abbreviated dialling numbers, EFadn 4FXX

  1617         // Abbreviated dialling numbers, EFadn 4FXX

  1608         if ( 0x4F == ( fileId >> 8 ) )

  1618         if ( 0x4F == ( fileId >> 8 ) )

  1609             {

  1619             {

  1610 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: ADN refresh.");

  1620 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: ADN refresh.");

  1612 

  1622 

  1613             refreshFiles |= KCacheAdn;

  1623             refreshFiles |= KCacheAdn;

  1614             }

  1624             }

  1615 

  1625 

  1616         startIndex = uiccSbApplPathOffset + sbLen;

  1626         startIndex = uiccSbApplPathOffset + sbLen;

  1639             }

  1649             }

  1640         }

  1650         }

  1641 

  1651 

  1642     // Check if we have any files to refresh in CommonTSY.

  1652     // Check if we have any files to refresh in CommonTSY.

  1643 TFLOGSTRING2("TSY: CMmPhoneMessHandler::HandleUiccRefresh: refreshFiles = %d", refreshFiles );

  1653 TFLOGSTRING2("TSY: CMmPhoneMessHandler::HandleUiccRefresh: refreshFiles = %d", refreshFiles );

  1645     if ( 0 < refreshFiles )

  1655     if ( 0 < refreshFiles )

  1646         {

  1656         {

  1647         iCommonTSYRefreshPending = ETrue;

  1657         iCommonTSYRefreshPending = ETrue;

  1648 

  1658 

  1649 TFLOGSTRING2("TSY: CMmPhoneMessHandler::HandleUiccRefresh: CommonTSY Refresh Pending = %d", iCommonTSYRefreshPending );

  1659 TFLOGSTRING2("TSY: CMmPhoneMessHandler::HandleUiccRefresh: CommonTSY Refresh Pending = %d", iCommonTSYRefreshPending );

  1651 

  1661 

  1652         CMmDataPackage dataPackage;

  1662         CMmDataPackage dataPackage;

  1653         dataPackage.PackData( &refreshFiles );

  1663         dataPackage.PackData( &refreshFiles );

  1654 

  1664 

  1655         // Complete. This will start the cache update process.

  1665         // Complete. This will start the cache update process.

  1677     iInternalRefreshFiles ^= KRefreshSms;

  1687     iInternalRefreshFiles ^= KRefreshSms;

  1678 

  1688 

  1679     if ( KErrNone == aError )

  1689     if ( KErrNone == aError )

  1680         {

  1690         {

  1681 TFLOGSTRING("TSY: CMmPhoneMessHandler::SmsCachingCompleted: nokiatsy sms caching completed");

  1691 TFLOGSTRING("TSY: CMmPhoneMessHandler::SmsCachingCompleted: nokiatsy sms caching completed");

  1683         UiccRefreshReq( UICC_REFRESH_DONE );

  1693         UiccRefreshReq( UICC_REFRESH_DONE );

  1684         }

  1694         }

  1685     else

  1695     else

  1686         {

  1696         {

  1687 TFLOGSTRING2("TSY: CMmPhoneMessHandler::SmsCachingCompleted: nokiatsy sms caching completed with error %d", aError);

  1697 TFLOGSTRING2("TSY: CMmPhoneMessHandler::SmsCachingCompleted: nokiatsy sms caching completed with error %d", aError);

  1689         UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1699         UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1690         }

  1700         }

  1691     }

  1701     }

  1692 

  1702 

  1693 // --------------------------------------------------------------------------

  1703 // --------------------------------------------------------------------------

  1700     iInternalRefreshFiles ^= KRefreshServiceTable;

  1710     iInternalRefreshFiles ^= KRefreshServiceTable;

  1701 

  1711 

  1702     if ( UICC_STATUS_OK == aError )

  1712     if ( UICC_STATUS_OK == aError )

  1703         {

  1713         {

  1704 TFLOGSTRING("TSY: CMmPhoneMessHandler::ServiceTableCachingCompleted: nokiatsy service table caching completed");

  1714 TFLOGSTRING("TSY: CMmPhoneMessHandler::ServiceTableCachingCompleted: nokiatsy service table caching completed");

  1706         UiccRefreshReq( UICC_REFRESH_DONE );

  1716         UiccRefreshReq( UICC_REFRESH_DONE );

  1707         }

  1717         }

  1708     else

  1718     else

  1709         {

  1719         {

  1710 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ServiceTableCachingCompleted: nokiatsy service table caching completed with error %d", aError);

  1720 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ServiceTableCachingCompleted: nokiatsy service table caching completed with error %d", aError);

  1712         UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1722         UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1713         }

  1723         }

  1714     }

  1724     }

  1715 

  1725 

  1716 // ----------------------------------------------------------------------------

  1726 // ----------------------------------------------------------------------------

  1725     iInternalRefreshFiles ^= KRefreshCallForwardingFlags;

  1735     iInternalRefreshFiles ^= KRefreshCallForwardingFlags;

  1726 

  1736 

  1727     if ( UICC_STATUS_OK == aError )

  1737     if ( UICC_STATUS_OK == aError )

  1728         {

  1738         {

  1729 TFLOGSTRING("TSY: CMmPhoneMessHandler::CallForwFlagsCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");

  1739 TFLOGSTRING("TSY: CMmPhoneMessHandler::CallForwFlagsCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");

  1731         UiccRefreshReq( UICC_REFRESH_DONE );

  1741         UiccRefreshReq( UICC_REFRESH_DONE );

  1732         }

  1742         }

  1733     else

  1743     else

  1734         {

  1744         {

  1735 TFLOGSTRING2("TSY: CMmPhoneMessHandler::CallForwFlagsCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);

  1745 TFLOGSTRING2("TSY: CMmPhoneMessHandler::CallForwFlagsCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);

  1737         UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1747         UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1738         }

  1748         }

  1739     }

  1749     }

  1740 

  1750 

  1741 // ----------------------------------------------------------------------------

  1751 // ----------------------------------------------------------------------------

  1756         oplRefreshOngoing = ETrue;

  1766         oplRefreshOngoing = ETrue;

  1757 

  1767 

  1758         if ( KErrNone == aError )

  1768         if ( KErrNone == aError )

  1759             {

  1769             {

  1760 TFLOGSTRING("TSY: CMmPhoneMessHandler::OplRulesCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");

  1770 TFLOGSTRING("TSY: CMmPhoneMessHandler::OplRulesCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");

  1762             UiccRefreshReq( UICC_REFRESH_DONE );

  1772             UiccRefreshReq( UICC_REFRESH_DONE );

  1763             }

  1773             }

  1764         else

  1774         else

  1765             {

  1775             {

  1766 TFLOGSTRING2("TSY: CMmPhoneMessHandler::OplRulesCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);

  1776 TFLOGSTRING2("TSY: CMmPhoneMessHandler::OplRulesCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);

  1768             UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1778             UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1769             }

  1779             }

  1770         }

  1780         }

  1771 

  1781 

  1772     return oplRefreshOngoing;

  1782     return oplRefreshOngoing;

  1785         iInternalRefreshFiles ^= KRefreshPnnRecord;

  1795         iInternalRefreshFiles ^= KRefreshPnnRecord;

  1786 

  1796 

  1787         if ( UICC_STATUS_OK == aError )

  1797         if ( UICC_STATUS_OK == aError )

  1788             {

  1798             {

  1789 TFLOGSTRING("TSY: CMmPhoneMessHandler::PnnRecordCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");

  1799 TFLOGSTRING("TSY: CMmPhoneMessHandler::PnnRecordCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");

  1791             UiccRefreshReq( UICC_REFRESH_DONE );

  1801             UiccRefreshReq( UICC_REFRESH_DONE );

  1792             }

  1802             }

  1793         else

  1803         else

  1794             {

  1804             {

  1795 TFLOGSTRING2("TSY: CMmPhoneMessHandler::PnnRecordCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);

  1805 TFLOGSTRING2("TSY: CMmPhoneMessHandler::PnnRecordCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);

  1797             UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1807             UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1798             }

  1808             }

  1799         }

  1809         }

  1800     }

  1810     }

  1801 

  1811 

  1812         iInternalRefreshFiles ^= KRefreshOnsName;

  1822         iInternalRefreshFiles ^= KRefreshOnsName;

  1813 

  1823 

  1814         if ( UICC_STATUS_OK == aError )

  1824         if ( UICC_STATUS_OK == aError )

  1815             {

  1825             {

  1816 TFLOGSTRING("TSY: CMmPhoneMessHandler::OnsNameCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");

  1826 TFLOGSTRING("TSY: CMmPhoneMessHandler::OnsNameCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");

  1818             UiccRefreshReq( UICC_REFRESH_DONE );

  1828             UiccRefreshReq( UICC_REFRESH_DONE );

  1819             }

  1829             }

  1820         else

  1830         else

  1821             {

  1831             {

  1822 TFLOGSTRING2("TSY: CMmPhoneMessHandler::OnsNameCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);

  1832 TFLOGSTRING2("TSY: CMmPhoneMessHandler::OnsNameCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);

  1824             UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1834             UiccRefreshReq( UICC_REFRESH_NOT_OK );

  1825             }

  1835             }

  1826         }

  1836         }

  1827     }

  1837     }

  1828 

  1838 

  1832 // ----------------------------------------------------------------------------

  1842 // ----------------------------------------------------------------------------

  1833 //

  1843 //

  1834 TInt CMmPhoneMessHandler::UiccReadEfEstReq()

  1844 TInt CMmPhoneMessHandler::UiccReadEfEstReq()

  1835     {

  1845     {

  1836 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadEfEstReq");

  1846 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadEfEstReq");

  1838 

  1848 

  1839     TInt ret( KErrNone );

  1849     TInt ret( KErrNone );

  1840 

  1850 

  1841     if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() &&

  1851     if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() &&

  1842         iMmUiccMessHandler->GetServiceStatus( KServiceAcl ) )

  1852         iMmUiccMessHandler->GetServiceStatus( KServiceAcl ) )

  1850             5 );

  1860             5 );

  1851         }

  1861         }

  1852     else

  1862     else

  1853         {

  1863         {

  1854 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadEfEstReq: card type is NOT UICC or ACL not supported in EFust");

  1864 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadEfEstReq: card type is NOT UICC or ACL not supported in EFust");

  1856         iACLIsProgress = EFalse;

  1866         iACLIsProgress = EFalse;

  1857         ret = KErrNotFound;

  1867         ret = KErrNotFound;

  1858         }

  1868         }

  1859     return ret;

  1869     return ret;

  1860     }

  1870     }

  1867 void CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp(

  1877 void CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp(

  1868     TInt aStatus,

  1878     TInt aStatus,

  1869     const TDesC8& aFileData )

  1879     const TDesC8& aFileData )

  1870     {

  1880     {

  1871 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp");

  1881 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp");

  1873 

  1883 

  1874     TInt ret( KErrNone );

  1884     TInt ret( KErrNone );

  1875     RMobilePhone::TAPNControlListServiceStatus aclStatus;

  1885     RMobilePhone::TAPNControlListServiceStatus aclStatus;

  1876 

  1886 

  1877     if( ( UICC_STATUS_OK == aStatus ) && ( 0 < aFileData.Length() ) )

  1887     if( ( UICC_STATUS_OK == aStatus ) && ( 0 < aFileData.Length() ) )

  1887             }

  1897             }

  1888         }

  1898         }

  1889     else

  1899     else

  1890         {

  1900         {

  1891 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp: EFest reading failed: 0x%x", aStatus);

  1901 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp: EFest reading failed: 0x%x", aStatus);

  1893         ret = KErrAccessDenied;

  1903         ret = KErrAccessDenied;

  1894         }

  1904         }

  1895 

  1905 

  1896     CMmDataPackage dataPackage;

  1906     CMmDataPackage dataPackage;

  1897 

  1907 

  1915 void CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp(

  1925 void CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp(

  1916     TInt aStatus,

  1926     TInt aStatus,

  1917     const TDesC8& aFileData )

  1927     const TDesC8& aFileData )

  1918     {

  1928     {

  1919 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp");

  1929 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp");

  1921 

  1931 

  1922     TInt ret( KErrNone );

  1932     TInt ret( KErrNone );

  1923     TBool completeNeeded( ETrue );

  1933     TBool completeNeeded( ETrue );

  1924     TUint8 aclState( 0 );

  1934     TUint8 aclState( 0 );

  1925 

  1935 

  1939             }

  1949             }

  1940         else

  1950         else

  1941             {

  1951             {

  1942             // ACL status already correct, let's complete

  1952             // ACL status already correct, let's complete

  1943 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: ACL status already correct, let's complete");

  1953 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: ACL status already correct, let's complete");

  1945             }

  1955             }

  1946         }

  1956         }

  1947     else if ( ( UICC_STATUS_OK == aStatus ) && ( ! aclState & KAclStateMask ) )

  1957     else if ( ( UICC_STATUS_OK == aStatus ) && ( ! aclState & KAclStateMask ) )

  1948         {

  1958         {

  1949         if ( RMobilePhone::EAPNControlListServiceEnabled == iAclStatus )

  1959         if ( RMobilePhone::EAPNControlListServiceEnabled == iAclStatus )

  1954             }

  1964             }

  1955         else

  1965         else

  1956             {

  1966             {

  1957             // ACL status already correct, let's complete

  1967             // ACL status already correct, let's complete

  1958 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: ACL status already correct, let's complete");

  1968 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: ACL status already correct, let's complete");

  1960             }

  1970             }

  1961         }

  1971         }

  1962     else

  1972     else

  1963         {

  1973         {

  1964         // EFest reading failed

  1974         // EFest reading failed

  1965 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: EFest reading failed: 0x%x", aStatus );

  1975 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: EFest reading failed: 0x%x", aStatus );

  1967         ret = KErrAccessDenied;

  1977         ret = KErrAccessDenied;

  1968         }

  1978         }

  1969 

  1979 

  1970     if( completeNeeded )

  1980     if( completeNeeded )

  1971         {

  1981         {

  1982 // ----------------------------------------------------------------------------

  1992 // ----------------------------------------------------------------------------

  1983 //

  1993 //

  1984 TInt CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq( TUint8 aOldAclState )

  1994 TInt CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq( TUint8 aOldAclState )

  1985     {

  1995     {

  1986 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq");

  1996 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq");

  1988 

  1998 

  1989     TInt ret( KErrNone );

  1999     TInt ret( KErrNone );

  1990     TUint8 newState;

  2000     TUint8 newState;

  1991     if( RMobilePhone::EAPNControlListServiceDisabled == iAclStatus )

  2001     if( RMobilePhone::EAPNControlListServiceDisabled == iAclStatus )

  1992         {

  2002         {

  2016             fileData );

  2026             fileData );

  2017         }

  2027         }

  2018     else

  2028     else

  2019         {

  2029         {

  2020 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq: card type is NOT UICC or ACL not supported in EFust");

  2030 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq: card type is NOT UICC or ACL not supported in EFust");

  2022         iACLIsProgress = EFalse;

  2032         iACLIsProgress = EFalse;

  2023         ret = KErrGeneral;

  2033         ret = KErrGeneral;

  2024         }

  2034         }

  2025     return ret;

  2035     return ret;

  2026     }

  2036     }

  2032 //

  2042 //

  2033 void CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp(

  2043 void CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp(

  2034     TInt aStatus )

  2044     TInt aStatus )

  2035     {

  2045     {

  2036 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp");

  2046 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp");

  2038     TInt ret( KErrAccessDenied );

  2048     TInt ret( KErrAccessDenied );

  2039 

  2049 

  2040     if( UICC_STATUS_OK == aStatus )

  2050     if( UICC_STATUS_OK == aStatus )

  2041         {

  2051         {

  2042         ret = KErrNone;

  2052         ret = KErrNone;

  2043         }

  2053         }

  2044     else

  2054     else

  2045         {

  2055         {

  2046 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp: writing failed: 0x%x", aStatus);

  2056 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp: writing failed: 0x%x", aStatus);

  2048         }

  2058         }

  2049 

  2059 

  2050     iACLIsProgress = EFalse; //set ACL flag

  2060     iACLIsProgress = EFalse; //set ACL flag

  2051     iMessageRouter->Complete(

  2061     iMessageRouter->Complete(

  2052         EMobilePhoneSetAPNControlListServiceStatus,

  2062         EMobilePhoneSetAPNControlListServiceStatus,

  2066 // ----------------------------------------------------------------------------

  2076 // ----------------------------------------------------------------------------

  2067 //

  2077 //

  2068 TInt CMmPhoneMessHandler::UiccReadAclReq()

  2078 TInt CMmPhoneMessHandler::UiccReadAclReq()

  2069     {

  2079     {

  2070 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadAclReq");

  2080 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadAclReq");

  2072 

  2082 

  2073     TInt ret( KErrNone );

  2083     TInt ret( KErrNone );

  2074 

  2084 

  2075     if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() &&

  2085     if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() &&

  2076         iMmUiccMessHandler->GetServiceStatus( KServiceAcl ) )

  2086         iMmUiccMessHandler->GetServiceStatus( KServiceAcl ) )

  2084             UICC_SFI_NOT_PRESENT );

  2094             UICC_SFI_NOT_PRESENT );

  2085         }

  2095         }

  2086     else

  2096     else

  2087         {

  2097         {

  2088 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadAclReq: card type is NOT UICC or ACL not supported in EFust");

  2098 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadAclReq: card type is NOT UICC or ACL not supported in EFust");

  2090         iACLIsProgress = EFalse;

  2100         iACLIsProgress = EFalse;

  2091         ret = KErrNotFound;

  2101         ret = KErrNotFound;

  2092         }

  2102         }

  2093 

  2103 

  2094     return ret;

  2104     return ret;

  2102 void CMmPhoneMessHandler::UiccReadAclResp(

  2112 void CMmPhoneMessHandler::UiccReadAclResp(

  2103     TInt aStatus,

  2113     TInt aStatus,

  2104     const TDesC8& aFileData )

  2114     const TDesC8& aFileData )

  2105     {

  2115     {

  2106 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadAclResp");

  2116 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadAclResp");

  2108     TInt ret( KErrNone );

  2118     TInt ret( KErrNone );

  2109     if ( ( UICC_STATUS_OK == aStatus ) &&

  2119     if ( ( UICC_STATUS_OK == aStatus ) &&

  2110         ( KApnDataIndex < aFileData.Length() ) )

  2120         ( KApnDataIndex < aFileData.Length() ) )

  2111         {

  2121         {

  2112         if( iAPNList )

  2122         if( iAPNList )

  2143                 break;

  2153                 break;

  2144                 }

  2154                 }

  2145             default:

  2155             default:

  2146                 {

  2156                 {

  2147 TFLOGSTRING2( "TSY: CMmPhoneMessHandler::UiccReadAclResp: unknown IPC (%d)", iOngoingAclIpc );

  2157 TFLOGSTRING2( "TSY: CMmPhoneMessHandler::UiccReadAclResp: unknown IPC (%d)", iOngoingAclIpc );

  2149                 iACLIsProgress = EFalse;

  2159                 iACLIsProgress = EFalse;

  2150                 break;

  2160                 break;

  2151                 }

  2161                 }

  2152             }

  2162             }

  2153         }

  2163         }

  2154     else

  2164     else

  2155         {

  2165         {

  2156 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccReadAclResp: reading failed: 0x%x", aStatus);

  2166 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccReadAclResp: reading failed: 0x%x", aStatus);

  2158         ret = KErrAccessDenied;

  2168         ret = KErrAccessDenied;

  2159         }

  2169         }

  2160 

  2170 

  2161     if( KErrNone != ret )

  2171     if( KErrNone != ret )

  2162         {

  2172         {

  2175         const TDesC8& aTlv,

  2185         const TDesC8& aTlv,

  2176         TInt aTotalEntries

  2186         TInt aTotalEntries

  2177         ) const

  2187         ) const

  2178     {

  2188     {

  2179 TFLOGSTRING2("TSY: CMmPhoneMessHandler::DecodeACL. Number of total entries: %d", aTotalEntries);

  2189 TFLOGSTRING2("TSY: CMmPhoneMessHandler::DecodeACL. Number of total entries: %d", aTotalEntries);

  2181 

  2191 

  2182     CDesC8ArrayFlat* apnList = new( ELeave ) CDesC8ArrayFlat( 1 );

  2192     CDesC8ArrayFlat* apnList = new( ELeave ) CDesC8ArrayFlat( 1 );

  2183     CleanupStack::PushL( apnList );

  2193     CleanupStack::PushL( apnList );

  2184 

  2194 

  2185     TInt offset( 0 );

  2195     TInt offset( 0 );

  2215 //

  2225 //

  2216 void CMmPhoneMessHandler::CompleteEnumerateAPNEntries()

  2226 void CMmPhoneMessHandler::CompleteEnumerateAPNEntries()

  2217     {

  2227     {

  2218     TInt indexCount( iAPNList->MdcaCount() );

  2228     TInt indexCount( iAPNList->MdcaCount() );

  2219 TFLOGSTRING2("TSY: CMmPhoneMessHandler::CompleteEnumerateAPNEntries. Number of APN's: %d",indexCount);

  2229 TFLOGSTRING2("TSY: CMmPhoneMessHandler::CompleteEnumerateAPNEntries. Number of APN's: %d",indexCount);

  2221 

  2231 

  2222     CMmDataPackage dataPackage;

  2232     CMmDataPackage dataPackage;

  2223     dataPackage.PackData( &indexCount );

  2233     dataPackage.PackData( &indexCount );

  2224 

  2234 

  2225     iACLIsProgress = EFalse;

  2235     iACLIsProgress = EFalse;

  2235 // --------------------------------------------------------------------------

  2245 // --------------------------------------------------------------------------

  2236 //

  2246 //

  2237 void CMmPhoneMessHandler::CompleteGetAPNName( TUint8 aIndex )

  2247 void CMmPhoneMessHandler::CompleteGetAPNName( TUint8 aIndex )

  2238     {

  2248     {

  2239 TFLOGSTRING("TSY: CMmPhoneMessHandler::CompleteGetAPNName ");

  2249 TFLOGSTRING("TSY: CMmPhoneMessHandler::CompleteGetAPNName ");

  2241 

  2251 

  2242     CMmDataPackage dataPackage;

  2252     CMmDataPackage dataPackage;

  2243     RMobilePhone::TAPNEntryV3 aclEntry;

  2253     RMobilePhone::TAPNEntryV3 aclEntry;

  2244     TInt err( KErrNone );

  2254     TInt err( KErrNone );

  2245 

  2255 

  2248         err = KErrOverflow;

  2258         err = KErrOverflow;

  2249         }

  2259         }

  2250     else

  2260     else

  2251         {

  2261         {

  2252 TFLOGSTRING2("TSY: CMmPhoneMessHandler::CompleteGetAPNName. Copy entry from index %d",aIndex);

  2262 TFLOGSTRING2("TSY: CMmPhoneMessHandler::CompleteGetAPNName. Copy entry from index %d",aIndex);

  2254         aclEntry.iApn.Copy( iAPNList->MdcaPoint( aIndex ) );

  2264         aclEntry.iApn.Copy( iAPNList->MdcaPoint( aIndex ) );

  2255         }

  2265         }

  2256 

  2266 

  2257     dataPackage.PackData( &aclEntry );

  2267     dataPackage.PackData( &aclEntry );

  2258 

  2268 

  2266 // --------------------------------------------------------------------------

  2276 // --------------------------------------------------------------------------

  2267 //

  2277 //

  2268 TInt CMmPhoneMessHandler::UiccDeleteApnEntry( TInt aIndex )

  2278 TInt CMmPhoneMessHandler::UiccDeleteApnEntry( TInt aIndex )

  2269     {

  2279     {

  2270 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccDeleteApnEntry ");

  2280 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccDeleteApnEntry ");

  2272 

  2282 

  2273     TInt ret;

  2283     TInt ret;

  2274     if ( iAPNList->MdcaCount() <= aIndex )

  2284     if ( iAPNList->MdcaCount() <= aIndex )

  2275         {

  2285         {

  2276         ret = KErrOverflow;

  2286         ret = KErrOverflow;

  2292 // --------------------------------------------------------------------------

  2302 // --------------------------------------------------------------------------

  2293 //

  2303 //

  2294 TInt CMmPhoneMessHandler::UiccWriteEfAclReq()

  2304 TInt CMmPhoneMessHandler::UiccWriteEfAclReq()

  2295     {

  2305     {

  2296 TFLOGSTRING( "TSY: CMmPhoneMessHandler::UiccWriteEfAclReq" );

  2306 TFLOGSTRING( "TSY: CMmPhoneMessHandler::UiccWriteEfAclReq" );

  2298 

  2308 

  2299     TInt ret( KErrNone );

  2309     TInt ret( KErrNone );

  2300 

  2310 

  2301     if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() &&

  2311     if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() &&

  2302         iMmUiccMessHandler->GetServiceStatus( KServiceAcl ) )

  2312         iMmUiccMessHandler->GetServiceStatus( KServiceAcl ) )

  2325             fileData );

  2335             fileData );

  2326         }

  2336         }

  2327     else

  2337     else

  2328         {

  2338         {

  2329 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccWriteEfAclReq: card type is NOT UICC or ACL not supported in EFust");

  2339 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccWriteEfAclReq: card type is NOT UICC or ACL not supported in EFust");

  2331         iACLIsProgress = EFalse;

  2341         iACLIsProgress = EFalse;

  2332         ret = KErrNotFound;

  2342         ret = KErrNotFound;

  2333         }

  2343         }

  2334     return ret;

  2344     return ret;

  2335     }

  2345     }

  2340 // --------------------------------------------------------------------------

  2350 // --------------------------------------------------------------------------

  2341 //

  2351 //

  2342 void CMmPhoneMessHandler::UiccWriteEfAclResp( TInt aStatus )

  2352 void CMmPhoneMessHandler::UiccWriteEfAclResp( TInt aStatus )

  2343     {

  2353     {

  2344 TFLOGSTRING( "TSY: CMmPhoneMessHandler::UiccWriteEfAclResp" );

  2354 TFLOGSTRING( "TSY: CMmPhoneMessHandler::UiccWriteEfAclResp" );

  2346 

  2356 

  2347     TInt ret( KErrNone );

  2357     TInt ret( KErrNone );

  2348     if( UICC_STATUS_OK != aStatus )

  2358     if( UICC_STATUS_OK != aStatus )

  2349         {

  2359         {

  2350 TFLOGSTRING2( "TSY: CMmPhoneMessHandler::UiccWriteEfAclResp: EFacl writing failed: 0x%x", aStatus );

  2360 TFLOGSTRING2( "TSY: CMmPhoneMessHandler::UiccWriteEfAclResp: EFacl writing failed: 0x%x", aStatus );

  2352 

  2362 

  2353         ret = KErrAccessDenied;

  2363         ret = KErrAccessDenied;

  2354         }

  2364         }

  2355 

  2365 

  2356     iACLIsProgress = EFalse;

  2366     iACLIsProgress = EFalse;

  2365 // --------------------------------------------------------------------------

  2375 // --------------------------------------------------------------------------

  2366 //

  2376 //

  2367 TUint16 CMmPhoneMessHandler::ACLLength( CDesC8ArrayFlat* aApnList ) const

  2377 TUint16 CMmPhoneMessHandler::ACLLength( CDesC8ArrayFlat* aApnList ) const

  2368     {

  2378     {

  2369 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ACLLength. Count: %d", aApnList->MdcaCount());

  2379 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ACLLength. Count: %d", aApnList->MdcaCount());

  2371 

  2381 

  2372     TUint16 length( 0 );

  2382     TUint16 length( 0 );

  2373 

  2383 

  2374     if ( aApnList )

  2384     if ( aApnList )

  2375         {

  2385         {

  2383     // result is incremented by one because of EFacl contains number of tlv objects

  2393     // result is incremented by one because of EFacl contains number of tlv objects

  2384     // as first byte of the file data

  2394     // as first byte of the file data

  2385     length++;

  2395     length++;

  2386 

  2396 

  2387 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ACLLength. ACL len: %d", length);

  2397 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ACLLength. ACL len: %d", length);

  2389 

  2399 

  2390     return length;

  2400     return length;

  2391     }

  2401     }

  2392 

  2402 

  2393 

  2403 

  2404     const TUint16 aFileId,

  2414     const TUint16 aFileId,

  2405     const TUint8 aFileIdSfi,

  2415     const TUint8 aFileIdSfi,

  2406     const TDesC8& aFileData )

  2416     const TDesC8& aFileData )

  2407     {

  2417     {

  2408 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccApplCmdReq");

  2418 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccApplCmdReq");

  2410 

  2420 

  2411     TInt ret( KErrNone );

  2421     TInt ret( KErrNone );

  2412     TBuf8<KFilePathLength> filePath;

  2422     TBuf8<KFilePathLength> filePath;

  2413     filePath.Append( KMasterFileId >> 8 );

  2423     filePath.Append( KMasterFileId >> 8 );

  2414     filePath.Append( KMasterFileId );

  2424     filePath.Append( KMasterFileId );