Mercurial Mercurial > oss > FCL > sf > incubator > modemadaptation / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
adaptationlayer/tsy/nokiatsy_dll/src/cmmphonemesshandler.cpp
changeset 5 8ccc39f9d787
parent 0 63b37f68c1ce
child 8 6295dc2169f3
equal deleted inserted replaced
4:510c70acdbf6 5:8ccc39f9d787 
     9 * Initial Contributors:
 
     9 * Initial Contributors:
 
    10 * Nokia Corporation - initial contribution.
 
    10 * Nokia Corporation - initial contribution.
 
    11 *
 
    11 *
 
    12 * Contributors:
 
    12 * Contributors:
 
    13 *
 
    13 *
 
    14 * Description: 
    14 * Description:
 
    15 *
 
    15 *
 
    16 */
 
    16 */
 
    17 
    17 
    18 
    18 
    19 
    19 
    25 #include "cmmstaticutility.h"
 
    25 #include "cmmstaticutility.h"
 
    26 #include "cmmsupplservmesshandler.h"
 
    26 #include "cmmsupplservmesshandler.h"
 
    27 #include "cmmnetmesshandler.h"
 
    27 #include "cmmnetmesshandler.h"
 
    28 #include "cmmnetoperatornamehandler.h"
 
    28 #include "cmmnetoperatornamehandler.h"
 
    29 #include "tsylogger.h"
 
    29 #include "tsylogger.h"
 
    30 #include "cmmuiccmesshandler.h"
 
    30 #include "cmmphonebookoperationinit.h"
 
    31 
    31 
    32 #include <call_modemisi.h>
 
    32 #include <call_modemisi.h>
 
    33 #include <ctsy/pluginapi/cmmdatapackage.h>
 
    33 #include <ctsy/pluginapi/cmmdatapackage.h>
 
    34 #include <csdisi.h>
 
    34 #include <csdisi.h>
 
    35 #include <gpdsisi.h>
 
    35 #include <gpdsisi.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 
    51 
    52 #include "osttracedefinitions.h"
 
    52 #include "OstTraceDefinitions.h"
 
    53 #ifdef OST_TRACE_COMPILER_IN_USE
 
    53 #ifdef OST_TRACE_COMPILER_IN_USE
 
    54 #include "cmmphonemesshandlertraces.h"
 
    54 #include "cmmphonemesshandlerTraces.h"
 
    55 #endif
 
    55 #endif
 
    56 
    56 
    57 // EXTERNAL DATA STRUCTURES
 
    57 // EXTERNAL DATA STRUCTURES
 
    58     //None
 
    58     //None
 
    59 
    59 
    67 
    67 
    68 const TUint8 KPhoneTransId = 6; //hard coded transaction ID
 
    68 const TUint8 KPhoneTransId = 6; //hard coded transaction ID
 
    69 const TUint8 KImsiSize = 8;
 
    69 const TUint8 KImsiSize = 8;
 
    70 const TUint8 KServiceProviderSize = 36;
 
    70 const TUint8 KServiceProviderSize = 36;
 
    71 const TUint8 KSpnFileSize = 16;
 
    71 const TUint8 KSpnFileSize = 16;
 
       
    72 
       
    73 const TUint8 KServiceAcl( 35 );
 
       
    74 const TUint8 KAclStateMask( 4 );
 
       
    75 const TUint8 KNumOfApnsIndex( 0 );
 
       
    76 const TUint8 KApnDataIndex( 1 );
 
    72 
    77 
    73 // ------------------------------------------------------
 
    78 // ------------------------------------------------------
 
    74 // --- Alternate Line Service (ALS)-related constants ---
 
    79 // --- Alternate Line Service (ALS)-related constants ---
 
    75 // ------------------------------------------------------
 
    80 // ------------------------------------------------------
 
    76 // Consts for mapping the Als Line values, as used in SIMSON's
 
    81 // Consts for mapping the Als Line values, as used in SIMSON's
 
   151 #else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 
   156 #else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 
   152         PN_MODEM_INFO,
 
   157         PN_MODEM_INFO,
 
   153 #endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 
   158 #endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 
   154         INFO_SERIAL_NUMBER_READ_RESP );
 
   159         INFO_SERIAL_NUMBER_READ_RESP );
 
   155 
   160 
       
   161     aPhoNetReceiver->RegisterL(
 
       
   162         phoneMessHandler,
 
       
   163         PN_UICC,
 
       
   164         UICC_REFRESH_RESP );
 
       
   165 
       
   166     aPhoNetReceiver->RegisterL(
 
       
   167         phoneMessHandler,
 
       
   168         PN_UICC,
 
       
   169         UICC_REFRESH_IND );
 
       
   170 
   156     CleanupStack::Pop( phoneMessHandler );
 
   171     CleanupStack::Pop( phoneMessHandler );
 
   157 
   172 
   158     return phoneMessHandler;
 
   173     return phoneMessHandler;
 
   159     }
 
   174     }
 
   160 
   175 
   178 
   193 
   179     iMessageRouter = aMessageRouter;
 
   194     iMessageRouter = aMessageRouter;
 
   180 
   195 
   181     iCommonTSYRefreshPending = EFalse;
 
   196     iCommonTSYRefreshPending = EFalse;
 
   182     iRefreshError = EFalse;
 
   197     iRefreshError = EFalse;
 
   183 
   198     iCompleteRefresfDone = EFalse;
 
   184     iInternalRefreshFiles = 0;
 
   199     iInternalRefreshFiles = 0;
 
   185 
   200 
   186     SubscribeEventsFromPhoNet();
 
   201     SubscribeEventsFromPhoNet();
 
   187 
   202 
   188     }
 
   203     }
 
   282             PN_SMS, SMS_CB_ROUTING_IND,
 
   297             PN_SMS, SMS_CB_ROUTING_IND,
 
   283 
   298 
   284         // UICC SERVER INDICATIONS
 
   299         // UICC SERVER INDICATIONS
 
   285             PN_UICC, UICC_CARD_IND,
 
   300             PN_UICC, UICC_CARD_IND,
 
   286             PN_UICC, UICC_IND,
 
   301             PN_UICC, UICC_IND,
 
       
   302             PN_UICC, UICC_REFRESH_IND,
 
   287 
   303 
   288 #ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
 
   304 #ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
 
   289         // MTC SERVER INDICATIONS
 
   305         // MTC SERVER INDICATIONS
 
   290             PN_MTC, MTC_STATE_INFO_IND,
 
   306             PN_MTC, MTC_STATE_INFO_IND,
 
   291 #else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 
   307 #else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 
   387         case EMobilePhoneGetServiceProviderName:
 
   403         case EMobilePhoneGetServiceProviderName:
 
   388             {
 
   404             {
 
   389             ret = UiccReadServiceProviderName();
 
   405             ret = UiccReadServiceProviderName();
 
   390             break;
 
   406             break;
 
   391             }
 
   407             }
 
       
   408         case EMmTsySimRefreshDoneIPC:
 
       
   409             {
 
       
   410             iCommonTSYRefreshPending = EFalse;
 
       
   411             TBool readError;
 
       
   412             aDataPackage->UnPackData( readError );
 
       
   413 
       
   414             if ( ! readError )
 
       
   415                 {
 
       
   416 TFLOGSTRING("TSY: CMmPhoneMessHandler::ExtFuncL: commontsy refresh successfully completed ==> REFRESH_DONE");
 
       
   417 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_EXTFUNCL, "CMmPhoneMessHandler::ExtFuncL: commontsy refresh successfully completed ==> REFRESH_DONE" );
 
       
   418                 ret = UiccRefreshReq( UICC_REFRESH_DONE );
 
       
   419                 }
 
       
   420             else
 
       
   421                 {
 
       
   422 TFLOGSTRING("TSY: CMmPhoneMessHandler::ExtFuncL: commontsy refresh completed with an error ==> REFRESH_DONE");
 
       
   423 OstTrace0( TRACE_NORMAL, DUP2_CMMPHONEMESSHANDLER_EXTFUNCL, "CMmPhoneMessHandler::ExtFuncL: commontsy refresh completed with an error ==> REFRESH_DONE" );
 
       
   424                 ret = UiccRefreshReq( UICC_REFRESH_NOT_OK );
 
       
   425                 }
 
       
   426             break;
 
       
   427             }
 
       
   428 
       
   429         case EMobilePhoneGetAPNControlListServiceStatus:
 
       
   430             {
 
       
   431             if( !iACLIsProgress )
 
       
   432                 {
 
       
   433                 iOngoingAclIpc = EMobilePhoneGetAPNControlListServiceStatus;
 
       
   434                 iACLIsProgress = ETrue;
 
       
   435                 ret = UiccReadEfEstReq();
 
       
   436                 }
 
       
   437             else
 
       
   438                 {
 
       
   439                 ret = KErrInUse;
 
       
   440                 }
 
       
   441             break;
 
       
   442             }
 
       
   443         case EMobilePhoneSetAPNControlListServiceStatus:
 
       
   444             {
 
       
   445             if( !iACLIsProgress )
 
       
   446                 {
 
       
   447                 iOngoingAclIpc = EMobilePhoneSetAPNControlListServiceStatus;
 
       
   448                 iACLIsProgress = ETrue;
 
       
   449                 aDataPackage->UnPackData( iAclStatus );
 
       
   450                 ret = UiccReadEfEstReq();
 
       
   451                 }
 
       
   452             else
 
       
   453                 {
 
       
   454                 ret = KErrInUse;
 
       
   455                 }
 
       
   456             break;
 
       
   457             }
 
       
   458         case EMobilePhoneDeleteAPNName:
 
       
   459             {
 
       
   460             if( !iACLIsProgress )
 
       
   461                 {
 
       
   462                 iACLIsProgress = ETrue;
 
       
   463                 iOngoingAclIpc = EMobilePhoneDeleteAPNName;
 
       
   464                 aDataPackage->UnPackData( iAPNReadOrDeleteIndex );
 
       
   465                 if( !iAPNList )
 
       
   466                     {
 
       
   467                     ret = UiccReadAclReq();
 
       
   468                     }
 
       
   469                 else
 
       
   470                     {
 
       
   471                     ret = UiccDeleteApnEntry( iAPNReadOrDeleteIndex );
 
       
   472                     }
 
       
   473                 }
 
       
   474             else
 
       
   475                 {
 
       
   476                 ret = KErrInUse;
 
       
   477                 }
 
       
   478             break;
 
       
   479             }
 
       
   480         case EMobilePhoneAppendAPNName:
 
       
   481             {
 
       
   482             if( !iACLIsProgress )
 
       
   483                 {
 
       
   484                 iACLIsProgress = ETrue;
 
       
   485                 iOngoingAclIpc = EMobilePhoneAppendAPNName;
 
       
   486                 RMobilePhone::TAPNEntryV3* apnEntryName( NULL );
 
       
   487                 aDataPackage->UnPackData( &apnEntryName );
 
       
   488                 iAPNDataBuffer =  *apnEntryName;
 
       
   489 
       
   490                 if( !iAPNList )
 
       
   491                     {
 
       
   492                     ret = UiccReadAclReq();
 
       
   493                     }
 
       
   494                 else
 
       
   495                     {
 
       
   496                     iAPNList->AppendL( iAPNDataBuffer.iApn );
 
       
   497                     ret = UiccWriteEfAclReq();
 
       
   498                     }
 
       
   499                 }
 
       
   500             else
 
       
   501                 {
 
       
   502                 ret = KErrInUse;
 
       
   503                 }
 
       
   504             break;
 
       
   505             }
 
       
   506         case EMobilePhoneEnumerateAPNEntries:
 
       
   507             {
 
       
   508             if( !iAPNList )
 
       
   509                 {
 
       
   510                 if( !iACLIsProgress )
 
       
   511                     {
 
       
   512                     iACLIsProgress = ETrue;
 
       
   513                     iOngoingAclIpc = EMobilePhoneEnumerateAPNEntries;
 
       
   514                     ret = UiccReadAclReq();
 
       
   515                     }
 
       
   516                 else
 
       
   517                     {
 
       
   518                     ret = KErrInUse;
 
       
   519                     }
 
       
   520                 }
 
       
   521             else
 
       
   522                 {
 
       
   523                 CompleteEnumerateAPNEntries();
 
       
   524                 }
 
       
   525             break;
 
       
   526             }
 
       
   527         case EMobilePhoneGetAPNname:
 
       
   528             {
 
       
   529             aDataPackage->UnPackData( iAPNReadOrDeleteIndex );
 
       
   530             if( !iAPNList )
 
       
   531                 {
 
       
   532                 if( !iACLIsProgress )
 
       
   533                     {
 
       
   534                     iACLIsProgress = ETrue;
 
       
   535                     iOngoingAclIpc = EMobilePhoneGetAPNname;
 
       
   536                     ret = UiccReadAclReq();
 
       
   537                     }
 
       
   538                 else
 
       
   539                     {
 
       
   540                     ret = KErrInUse;
 
       
   541                     }
 
       
   542                 }
 
       
   543             else
 
       
   544                 {
 
       
   545                 CompleteGetAPNName( iAPNReadOrDeleteIndex );
 
       
   546                 }
 
       
   547             break;
 
       
   548             }
 
       
   549 
   392         default:
 
   550         default:
 
   393             {
 
   551             {
 
   394 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ExtFuncL - Unknown IPC: %d", aIpc);
 
   552 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ExtFuncL - Unknown IPC: %d", aIpc);
 
   395 OstTrace1( TRACE_NORMAL, DUP7_CMMPHONEMESSHANDLER_EXTFUNCL, "CMmPhoneMessHandler::ExtFuncL;Unknown aIpc=%d", aIpc );
 
   553 OstTrace1( TRACE_NORMAL, DUP7_CMMPHONEMESSHANDLER_EXTFUNCL, "CMmPhoneMessHandler::ExtFuncL;Unknown aIpc=%d", aIpc );
 
   396             ret = KErrNotSupported;
 
   554             ret = KErrNotSupported;
 
   439 OstTrace0( TRACE_NORMAL, DUP4_CMMPHONEMESSHANDLER_RECEIVEMESSAGEL, "CMmPhoneMessHandler::ReceiveMessageL, switch resource - case PN_MODEM_INFO, switch messageId - default" );
 
   597 OstTrace0( TRACE_NORMAL, DUP4_CMMPHONEMESSHANDLER_RECEIVEMESSAGEL, "CMmPhoneMessHandler::ReceiveMessageL, switch resource - case PN_MODEM_INFO, switch messageId - default" );
 
   440                     break;
 
   598                     break;
 
   441                     }
 
   599                     }
 
   442                 }
 
   600                 }
 
   443             break; // end case PN_MODEM_INFO
 
   601             break; // end case PN_MODEM_INFO
 
       
   602             }
 
       
   603         case PN_UICC:
 
       
   604             {
 
       
   605             switch( messageId )
 
       
   606                 {
 
       
   607                 case UICC_REFRESH_IND:
 
       
   608                     {
 
       
   609                     UiccRefreshInd( aIsiMessage );
 
       
   610                     break;
 
       
   611                     }
 
       
   612                 case UICC_REFRESH_RESP:
 
       
   613                     {
 
       
   614                     UiccRefreshResp( aIsiMessage );
 
       
   615                     break;
 
       
   616                     }
 
       
   617                 default:
 
       
   618                     {
 
       
   619                     break;
 
       
   620                     }
 
       
   621                 }
 
       
   622             break;
 
   444             }
 
   623             }
 
   445         default:
 
   624         default:
 
   446             {
 
   625             {
 
   447 TFLOGSTRING("TSY: CMmPhoneMessHandler::ReceiveMessageL, switch resource - default.\n" );
 
   626 TFLOGSTRING("TSY: CMmPhoneMessHandler::ReceiveMessageL, switch resource - default.\n" );
 
   448 OstTrace0( TRACE_NORMAL, DUP5_CMMPHONEMESSHANDLER_RECEIVEMESSAGEL, "CMmPhoneMessHandler::ReceiveMessageL, switch resource - default" );
 
   627 OstTrace0( TRACE_NORMAL, DUP5_CMMPHONEMESSHANDLER_RECEIVEMESSAGEL, "CMmPhoneMessHandler::ReceiveMessageL, switch resource - default" );
 
   964 // -----------------------------------------------------------------------------
 
  1143 // -----------------------------------------------------------------------------
 
   965 //
 
  1144 //
 
   966 TInt CMmPhoneMessHandler::ProcessUiccMsg(
 
  1145 TInt CMmPhoneMessHandler::ProcessUiccMsg(
 
   967     TInt aTraId,
 
  1146     TInt aTraId,
 
   968     TInt aStatus,
 
  1147     TInt aStatus,
 
       
  1148     TUint8 /*aDetails*/,
 
   969     const TDesC8& aFileData )
 
  1149     const TDesC8& aFileData )
 
   970     {
 
  1150     {
 
   971 TFLOGSTRING3("TSY: CMmPhoneMessHandler::ProcessUiccMsg, transaction ID: %d, status %d", aTraId, aStatus );
 
  1151 TFLOGSTRING3("TSY: CMmPhoneMessHandler::ProcessUiccMsg, transaction ID: %d, status %d", aTraId, aStatus );
 
   972 OstTraceExt2( TRACE_NORMAL, CMMPHONEMESSHANDLER_PROCESSUICCMSG, "CMmPhoneMessHandler::ProcessUiccMsg;aTraId=%d;aStatus=%d", aTraId, aStatus );
 
  1152 OstTraceExt2( TRACE_NORMAL, CMMPHONEMESSHANDLER_PROCESSUICCMSG, "CMmPhoneMessHandler::ProcessUiccMsg;aTraId=%d;aStatus=%d", aTraId, aStatus );
 
   973 
  1153 
   998             break;
 
  1178             break;
 
   999             }
 
  1179             }
 
  1000         case ETrIdWriteDynamicFlags:
 
  1180         case ETrIdWriteDynamicFlags:
 
  1001             {
 
  1181             {
 
  1002             UiccWriteDynamicFlagsResp( aStatus );
 
  1182             UiccWriteDynamicFlagsResp( aStatus );
 
       
  1183             break;
 
       
  1184             }
 
       
  1185         case ETrIdAclStatusReadEfEst:
 
       
  1186             {
 
       
  1187             if( EMobilePhoneGetAPNControlListServiceStatus == iOngoingAclIpc )
 
       
  1188                 {
 
       
  1189                 UiccGetAclStatusReadEfEstResp( aStatus, aFileData );
 
       
  1190                 }
 
       
  1191             else if( EMobilePhoneSetAPNControlListServiceStatus == iOngoingAclIpc )
 
       
  1192                 {
 
       
  1193                 UiccSetAclStatusReadEfEstResp( aStatus, aFileData );
 
       
  1194                 }
 
       
  1195             break;
 
       
  1196             }
 
       
  1197         case ETrIdAclStatusWriteEfEst:
 
       
  1198             {
 
       
  1199             UiccSetAclStatusWriteEfEstResp( aStatus );
 
       
  1200             break;
 
       
  1201             }
 
       
  1202         case ETrIdAclReadEfAcl:
 
       
  1203             {
 
       
  1204             UiccReadAclResp( aStatus, aFileData );
 
       
  1205             break;
 
       
  1206             }
 
       
  1207         case ETrIdAclWriteEfAcl:
 
       
  1208             {
 
       
  1209             UiccWriteEfAclResp( aStatus );
 
  1003             break;
 
  1210             break;
 
  1004             }
 
  1211             }
 
  1005         default:
 
  1212         default:
 
  1006             {
 
  1213             {
 
  1007 TFLOGSTRING("TSY: CMmPhoneMessHandler::ProcessUiccMsg - unknown transaction ID" );
 
  1214 TFLOGSTRING("TSY: CMmPhoneMessHandler::ProcessUiccMsg - unknown transaction ID" );
 
  1212     // Reset iServiceProviderName for next time.
 
  1419     // Reset iServiceProviderName for next time.
 
  1213     iServiceProviderName.iSPName.Zero();
 
  1420     iServiceProviderName.iSPName.Zero();
 
  1214     iServiceProviderName.iPLMNField.Zero();
 
  1421     iServiceProviderName.iPLMNField.Zero();
 
  1215     }
 
  1422     }
 
  1216 
  1423 
       
  1424 // --------------------------------------------------------------------------
 
       
  1425 // CMmPhoneMessHandler::UiccRefreshInd
 
       
  1426 //
 
       
  1427 // --------------------------------------------------------------------------
 
       
  1428 //
 
       
  1429 void CMmPhoneMessHandler::UiccRefreshInd( const TIsiReceiveC &aIsiMessage )
 
       
  1430     {
 
       
  1431 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccRefreshInd");
 
       
  1432 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCREFRESHIND, "CMmPhoneMessHandler::UiccRefreshInd" );
 
       
  1433     TUint8 serviceType( aIsiMessage.Get8bit(
 
       
  1434         ISI_HEADER_SIZE + UICC_REFRESH_IND_OFFSET_SERVICETYPE ) );
 
       
  1435     if ( UICC_REFRESH_PERMISSION == serviceType )
 
       
  1436         {
 
       
  1437         UiccRefreshReq( UICC_REFRESH_OK );
 
       
  1438         }
 
       
  1439     else if ( UICC_REFRESH_NOW == serviceType )
 
       
  1440         {
 
       
  1441         HandleUiccRefresh( aIsiMessage );
 
       
  1442         }
 
       
  1443     }
 
       
  1444 
       
  1445 // --------------------------------------------------------------------------
 
       
  1446 // CMmPhoneMessHandler::UiccRefreshResp
 
       
  1447 //
 
       
  1448 // --------------------------------------------------------------------------
 
       
  1449 //
 
       
  1450 void CMmPhoneMessHandler::UiccRefreshResp( const TIsiReceiveC &aIsiMessage )
 
       
  1451     {
 
       
  1452 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccRefreshResp");
 
       
  1453 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCREFRESHRESP, "CMmPhoneMessHandler::UiccRefreshResp" );
 
       
  1454     if ( iCompleteRefresfDone )
 
       
  1455         {
 
       
  1456         TUint8 status( aIsiMessage.Get8bit(
 
       
  1457             ISI_HEADER_SIZE + UICC_REFRESH_RESP_OFFSET_STATUS ) );
 
       
  1458         TInt err( KErrNone );
 
       
  1459         if ( UICC_STATUS_OK != status )
 
       
  1460             {
 
       
  1461             err = KErrGeneral;
 
       
  1462             }
 
       
  1463         iMessageRouter->Complete( EMmTsySimRefreshDoneIPC, err );
 
       
  1464         iCompleteRefresfDone = EFalse;
 
       
  1465         }
 
       
  1466     }
 
       
  1467 
       
  1468 // --------------------------------------------------------------------------
 
       
  1469 // CMmPhoneMessHandler::UiccRefreshReq
 
       
  1470 //
 
       
  1471 // --------------------------------------------------------------------------
 
       
  1472 //
 
       
  1473 TInt CMmPhoneMessHandler::UiccRefreshReq( TUint8 aStatus )
 
       
  1474     {
 
       
  1475 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccRefreshReq");
 
       
  1476 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCREFRESHREQ, "CMmPhoneMessHandler::UiccRefreshReq" );
 
       
  1477     TInt ret( KErrNone );
 
       
  1478 
       
  1479     // If there was error in cacheing some file, set internal flag
 
       
  1480     if ( UICC_REFRESH_NOT_OK == aStatus )
 
       
  1481         {
 
       
  1482         iRefreshError = ETrue;
 
       
  1483         }
 
       
  1484 
       
  1485     // If NTSY or CTSY cacheing is ongoing, message is not sent
 
       
  1486     if ( ! iCommonTSYRefreshPending && ! iInternalRefreshFiles )
 
       
  1487         {
 
       
  1488         if ( iRefreshError ) // Some cacheing was failed, set error status
 
       
  1489             {
 
       
  1490             aStatus = UICC_REFRESH_NOT_OK;
 
       
  1491             }
 
       
  1492 
       
  1493         TIsiSend isiMsg( iPhoNetSender->SendBufferDes() );
 
       
  1494         isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC );
 
       
  1495         isiMsg.Set8bit( ISI_HEADER_OFFSET_TRANSID, KPhoneTransId );
 
       
  1496         isiMsg.Set8bit( ISI_HEADER_OFFSET_MESSAGEID, UICC_REFRESH_REQ );
 
       
  1497         isiMsg.Set8bit( ISI_HEADER_SIZE + UICC_REFRESH_REQ_OFFSET_SERVICETYPE,
 
       
  1498             UICC_REFRESH_STATUS );
 
       
  1499         isiMsg.Set8bit( ISI_HEADER_SIZE + UICC_REFRESH_REQ_OFFSET_STATUS,
 
       
  1500             aStatus );
 
       
  1501         isiMsg.Set8bit( ISI_HEADER_SIZE + UICC_REFRESH_REQ_OFFSET_CLIENTID,
 
       
  1502             iMmUiccMessHandler->GetUiccClientId() );
 
       
  1503         isiMsg.Set16bit( ISI_HEADER_SIZE + UICC_REFRESH_REQ_OFFSET_FILLERBYTE1,
 
       
  1504             KPadding );
 
       
  1505         isiMsg.Set8bit( ISI_HEADER_SIZE + UICC_REFRESH_REQ_OFFSET_NSB,
 
       
  1506             0 ); // No subblocks
 
       
  1507 
       
  1508         ret = iPhoNetSender->Send( isiMsg.Complete() );
 
       
  1509         iRefreshError = EFalse;
 
       
  1510 
       
  1511         // When NTSY/CTSY refresh was performed, set iCompleteRefresfDone flag
 
       
  1512         // that IPC EMmTsySimRefreshDoneIPC will be completed to CTSY
 
       
  1513         if ( UICC_REFRESH_DONE == aStatus || UICC_REFRESH_NOT_OK == aStatus )
 
       
  1514             {
 
       
  1515             iCompleteRefresfDone = ETrue;
 
       
  1516             }
 
       
  1517         }
 
       
  1518     return ret;
 
       
  1519     }
 
       
  1520 
       
  1521 // --------------------------------------------------------------------------
 
       
  1522 // CMmPhoneMessHandler::HandleUiccRefresh
 
       
  1523 //
 
       
  1524 // --------------------------------------------------------------------------
 
       
  1525 //
 
       
  1526 void CMmPhoneMessHandler::HandleUiccRefresh( const TIsiReceiveC &aIsiMessage )
 
       
  1527     {
 
       
  1528 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh" );
 
       
  1529 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh" );
 
       
  1530 
       
  1531     TUint16 refreshFiles( 0 );
 
       
  1532     TBool enabledServicesChanged( EFalse );
 
       
  1533     TUint startIndex( ISI_HEADER_SIZE + SIZE_UICC_REFRESH_IND );
 
       
  1534 
       
  1535     // There is one subblock UICC_SB_APPL_PATH per refreshed file
 
       
  1536     TUint uiccSbApplPathOffset( 0 );
 
       
  1537     while ( KErrNone == aIsiMessage.FindSubBlockOffsetById(
 
       
  1538         startIndex,
 
       
  1539         UICC_SB_APPL_PATH,
 
       
  1540         EIsiSubBlockTypeId16Len16,
 
       
  1541         uiccSbApplPathOffset ) )
 
       
  1542         {
 
       
  1543         TUint16 sbLen( aIsiMessage.Get16bit(
 
       
  1544             uiccSbApplPathOffset + UICC_SB_APPL_PATH_OFFSET_SBLEN ) );
 
       
  1545 
       
  1546         // Get file id
 
       
  1547         TUint16 fileId( aIsiMessage.Get16bit(
 
       
  1548             uiccSbApplPathOffset + UICC_SB_APPL_PATH_OFFSET_EF ) );
 
       
  1549 
       
  1550         switch( fileId )
 
       
  1551             {
 
       
  1552             case KElemFileSmsParams: // 6F42, SMS parameters
 
       
  1553                 {
 
       
  1554 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: SMSP refresh.");
 
       
  1555 OstTrace0( TRACE_NORMAL, DUP2_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: SMSP refresh" );
 
       
  1556                 refreshFiles |= KCacheSmsParams;
 
       
  1557                 break;
 
       
  1558                 }
 
       
  1559             case KElemFileFixedDiallingNumbers: // 6F3B, Storage FDN
 
       
  1560                 {
 
       
  1561 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: FDN refresh");
 
       
  1562 OstTrace0( TRACE_NORMAL, DUP3_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: FDN refresh" );
 
       
  1563                 refreshFiles |= KCacheFdn;
 
       
  1564                 break;
 
       
  1565                 }
 
       
  1566             case KElemSimServiceTable: // 6F38, Service table
 
       
  1567                 {
 
       
  1568 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: ServiceTable refresh");
 
       
  1569 OstTrace0( TRACE_NORMAL, DUP4_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: ServiceTable refresh" );
 
       
  1570                 refreshFiles |= KCacheServiceTable;
 
       
  1571                 // Also internal service table cacheing is needed. EFalse means
 
       
  1572                 // no complete to CTSY.
 
       
  1573                 iInternalRefreshFiles |= KRefreshServiceTable;
 
       
  1574                 iMmUiccMessHandler->InitializeSimServiceTableCache( EFalse );
 
       
  1575                 break;
 
       
  1576                 }
 
       
  1577             case KElemFileDynFlagsOrange: // 6F9F, ALS
 
       
  1578                 {
 
       
  1579 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: ALS line refresh");
 
       
  1580 OstTrace0( TRACE_NORMAL, DUP5_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: ALS line." );
 
       
  1581                 refreshFiles |= KCacheALSline;
 
       
  1582                 break;
 
       
  1583                 }
 
       
  1584             case KElemFileShortMessages: // 6F3C, SMS
 
       
  1585                 {
 
       
  1586 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: SMS refresh");
 
       
  1587 OstTrace0( TRACE_NORMAL, DUP6_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: SMS refresh" );
 
       
  1588                 iInternalRefreshFiles |= KRefreshSms;
 
       
  1589                 iMessageRouter->GetSmsMessHandler()->InitializeSmsCache();
 
       
  1590                 break;
 
       
  1591                 }
 
       
  1592             case KElemFileAcl: // 6F57, ACL
 
       
  1593                 {
 
       
  1594 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: APN refresh");
 
       
  1595 OstTrace0( TRACE_NORMAL, DUP7_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: APN refresh" );
 
       
  1596                 iMessageRouter->Complete(
 
       
  1597                     EMobilePhoneNotifyAPNListChanged,
 
       
  1598                     KErrNone );
 
       
  1599 
       
  1600                 // Clear and delete cache
 
       
  1601                 if ( iAPNList )
 
       
  1602                     {
 
       
  1603                     iAPNList->Reset();
 
       
  1604                     delete iAPNList;
 
       
  1605                     iAPNList = NULL;
 
       
  1606                     }
 
       
  1607                 break;
 
       
  1608                 }
 
       
  1609             case KElemEst: // 6F56, Enabled service table
 
       
  1610                 {
 
       
  1611 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: ServiceTable enabled");
 
       
  1612 OstTrace0( TRACE_NORMAL, DUP8_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: ServiceTable enabled" );
 
       
  1613                 enabledServicesChanged = ETrue;
 
       
  1614                 break;
 
       
  1615                 }
 
       
  1616             case KElemFileCallFwdFlagsCphs:
 
       
  1617             case KElemFileCallFwdIndicationStatus:
 
       
  1618                 {
 
       
  1619 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: Call forwarding flags refresh ");
 
       
  1620 OstTrace0( TRACE_NORMAL, DUP9_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: Call forwarding flags refresh" );
 
       
  1621                 // Re-read call forwarding flags
 
       
  1622                 iInternalRefreshFiles |= KRefreshCallForwardingFlags;
 
       
  1623 
       
  1624                 iMessageRouter->GetSupplServHandler()->ExtFuncL(
 
       
  1625                     ECustomNotifyIccCallForwardingStatusChangeIPC,
 
       
  1626                     NULL );
 
       
  1627                 break;
 
       
  1628                 }
 
       
  1629             case KElemFileOpl: // 6FC6, Operator PLMN List
 
       
  1630                 {
 
       
  1631 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: OPL list refresh");
 
       
  1632 OstTrace0( TRACE_NORMAL, DUP10_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: OPL list refresh" );
 
       
  1633 
       
  1634                 iInternalRefreshFiles |= KRefreshOplRules;
 
       
  1635 
       
  1636                 iMessageRouter->
 
       
  1637                     GetNetMessHandler()->
 
       
  1638                     GetNetOperatorNameHandler()->
 
       
  1639                     UiccReadOplRecordCount();
 
       
  1640                 break;
 
       
  1641                 }
 
       
  1642             case KElemFilePlmnNetworkName: // 6FC5, PLMN Network Name
 
       
  1643                 {
 
       
  1644 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: PNN refresh");
 
       
  1645 OstTrace0( TRACE_NORMAL, DUP11_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: PNN refresh" );
 
       
  1646 
       
  1647                 iInternalRefreshFiles |= KRefreshPnnRecord;
 
       
  1648 
       
  1649                 // Get PNN record to be cached.
 
       
  1650                 TUint8 pnnIdentifier(
 
       
  1651                     iMessageRouter->
 
       
  1652                     GetNetMessHandler()->
 
       
  1653                     GetNetOperatorNameHandler()->
 
       
  1654                     GetPnnRecordIdentifierValue() );
 
       
  1655 
       
  1656                 iMessageRouter->
 
       
  1657                     GetNetMessHandler()->
 
       
  1658                     GetNetOperatorNameHandler()->
 
       
  1659                     UiccOperatorReqReadPnn( pnnIdentifier );
 
       
  1660                 break;
 
       
  1661                 }
 
       
  1662             case KElemFileOperatorName: // 6F14, Operator name
 
       
  1663                 {
 
       
  1664 TFLOGSTRING("TSY: CMmPhoneMessHandler::HandleUiccRefresh: ONS name refresh");
 
       
  1665 OstTrace0( TRACE_NORMAL, DUP12_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: ONS name refresh" );
 
       
  1666 
       
  1667                 iInternalRefreshFiles |= KRefreshOnsName;
 
       
  1668 
       
  1669                 iMessageRouter->
 
       
  1670                     GetNetMessHandler()->
 
       
  1671                     GetNetOperatorNameHandler()->
 
       
  1672                     UiccOperatorReq();
 
       
  1673                 break;
 
       
  1674                 }
 
       
  1675             default:
 
       
  1676                 {
 
       
  1677 TFLOGSTRING2("TSY:CMmPhoneMessHandler::HandleUiccRefresh:Unknown type: 0x%x", fileId);
 
       
  1678 OstTraceExt1( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh;fileId=%hu", fileId );
 
       
  1679                 break;
 
       
  1680                 }
 
       
  1681             }
 
       
  1682 
       
  1683         // Abbreviated dialling numbers, EFadn 4FXX
 
       
  1684         if ( 0x4F == ( fileId >> 8 ) )
 
       
  1685             {
 
       
  1686 TFLOGSTRING("TSY:CMmPhoneMessHandler::HandleUiccRefresh: ADN refresh.");
 
       
  1687 OstTrace0( TRACE_NORMAL, DUP13_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh: ADN refresh" );
 
       
  1688 
       
  1689             refreshFiles |= KCacheAdn;
 
       
  1690             }
 
       
  1691 
       
  1692         startIndex = uiccSbApplPathOffset + sbLen;
 
       
  1693         }
 
       
  1694 
       
  1695     // If Enabled Services table has been changed during the refresh,
 
       
  1696     // we need to make phonebook init phase 1 to enable UICC to send
 
       
  1697     // indication about FDN.
 
       
  1698     if ( enabledServicesChanged )
 
       
  1699         {
 
       
  1700         // In case of ADN or FDN phonebook refresh, CommonTSY is
 
       
  1701         // responsible of making phonebook initialization. => No need for
 
       
  1702         // internal initialization.
 
       
  1703         if ( !( refreshFiles & KCacheAdn )
 
       
  1704             && !( refreshFiles & KCacheFdn ) )
 
       
  1705             {
 
       
  1706             // Creating buffer for phonebook's name
 
       
  1707             TName phonebookName;
 
       
  1708             phonebookName.Copy( KInternalPhoneBookType );
 
       
  1709 
       
  1710             CPhoneBookDataPackage package;
 
       
  1711             package.SetPhoneBookName( phonebookName );
 
       
  1712 
       
  1713             iMessageRouter->PhoneBookStoreMessHandler()->ExtFuncL(
 
       
  1714                 EMmTsyPhoneBookStoreInitIPC,
 
       
  1715                 &package );
 
       
  1716             }
 
       
  1717         }
 
       
  1718 
       
  1719     // Check if we have any files to refresh in CommonTSY.
 
       
  1720 TFLOGSTRING2("TSY: CMmPhoneMessHandler::HandleUiccRefresh: refreshFiles = %d", refreshFiles );
 
       
  1721 OstTraceExt1( TRACE_NORMAL, DUP14_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh;refreshFiles=%hu", refreshFiles );
 
       
  1722     if ( 0 < refreshFiles )
 
       
  1723         {
 
       
  1724         iCommonTSYRefreshPending = ETrue;
 
       
  1725 
       
  1726 TFLOGSTRING2("TSY: CMmPhoneMessHandler::HandleUiccRefresh: CommonTSY Refresh Pending = %d", iCommonTSYRefreshPending );
 
       
  1727 OstTrace1( TRACE_NORMAL, DUP15_CMMPHONEMESSHANDLER_HANDLEUICCREFRESH, "CMmPhoneMessHandler::HandleUiccRefresh;iCommonTSYRefreshPending=%d", iCommonTSYRefreshPending );
 
       
  1728 
       
  1729         // Packed parameter: List of files needed to be refreshed.
 
       
  1730         CMmDataPackage dataPackage;
 
       
  1731         dataPackage.PackData( &refreshFiles );
 
       
  1732 
       
  1733         // Complete. This will start the cache update process.
 
       
  1734         iMessageRouter->Complete(
 
       
  1735             EMmTsySimRefreshNowIPC,
 
       
  1736             &dataPackage,
 
       
  1737             KErrNone );
 
       
  1738         }
 
       
  1739 
       
  1740     // Send refresh done to UICC only if there's no CTSY/NTSY
 
       
  1741     // caching ongoing.
 
       
  1742     if ( ! iCommonTSYRefreshPending && ! iInternalRefreshFiles )
 
       
  1743         {
 
       
  1744         UiccRefreshReq( UICC_REFRESH_DONE );
 
       
  1745         }
 
       
  1746     }
 
       
  1747 
       
  1748 // --------------------------------------------------------------------------
 
       
  1749 // CMmPhoneMessHandler::SmsCachingCompleted
 
       
  1750 // Checks if "Refresh Done" will be sent to UICC now or later.
 
       
  1751 // Counterpart is CMmPhoneMessHandler::ExtFuncL, case
 
       
  1752 // EMmTsySimRefreshDoneIPC.
 
       
  1753 // --------------------------------------------------------------------------
 
       
  1754 //
 
       
  1755 void CMmPhoneMessHandler::SmsCachingCompleted( TInt aError )
 
       
  1756     {
 
       
  1757     iInternalRefreshFiles ^= KRefreshSms;
 
       
  1758 
       
  1759     if ( KErrNone == aError )
 
       
  1760         {
 
       
  1761 TFLOGSTRING("TSY: CMmPhoneMessHandler::SmsCachingCompleted: nokiatsy sms caching completed");
 
       
  1762 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_SMSCACHINGCOMPLETED, "CMmPhoneMessHandler::SmsCachingCompleted: nokiatsy sms caching completed" );
 
       
  1763         UiccRefreshReq( UICC_REFRESH_DONE );
 
       
  1764         }
 
       
  1765     else
 
       
  1766         {
 
       
  1767 TFLOGSTRING2("TSY: CMmPhoneMessHandler::SmsCachingCompleted: nokiatsy sms caching completed with error %d", aError);
 
       
  1768 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_SMSCACHINGCOMPLETED, "CMmPhoneMessHandler::SmsCachingCompleted: nokiatsy sms caching completed with error" );
 
       
  1769         UiccRefreshReq( UICC_REFRESH_NOT_OK );
 
       
  1770         }
 
       
  1771     }
 
       
  1772 
       
  1773 // --------------------------------------------------------------------------
 
       
  1774 // CMmPhoneMessHandler::ServiceTableCachingCompleted
 
       
  1775 // Checks if "Refresh Done" will be sent to UICC now or later.
 
       
  1776 // --------------------------------------------------------------------------
 
       
  1777 //
 
       
  1778 void CMmPhoneMessHandler::ServiceTableCachingCompleted( TInt aError )
 
       
  1779     {
 
       
  1780     iInternalRefreshFiles ^= KRefreshServiceTable;
 
       
  1781 
       
  1782     if ( UICC_STATUS_OK == aError )
 
       
  1783         {
 
       
  1784 TFLOGSTRING("TSY: CMmPhoneMessHandler::ServiceTableCachingCompleted: nokiatsy service table caching completed");
 
       
  1785 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_SERVICETABLECACHINGCOMPLETED, "CMmPhoneMessHandler::ServiceTableCachingCompleted: nokiatsy service table caching completed" );
 
       
  1786         UiccRefreshReq( UICC_REFRESH_DONE );
 
       
  1787         }
 
       
  1788     else
 
       
  1789         {
 
       
  1790 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ServiceTableCachingCompleted: nokiatsy service table caching completed with error %d", aError);
 
       
  1791 OstTrace1( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_SERVICETABLECACHINGCOMPLETED, "CMmPhoneMessHandler::ServiceTableCachingCompleted: nokiatsy service table caching completed with error;aError=%d", aError );
 
       
  1792         UiccRefreshReq( UICC_REFRESH_NOT_OK );
 
       
  1793         }
 
       
  1794     }
 
       
  1795 
       
  1796 // ----------------------------------------------------------------------------
 
       
  1797 // CMmPhoneMessHandler::CallForwFlagsCachingCompleted
 
       
  1798 // Checks if "Refresh Done" will be sent to UICC.
 
       
  1799 // Counterpart is CMmPhoneMessHandler::ExtFuncL, case
 
       
  1800 // EMmTsySimRefreshDoneIPC.
 
       
  1801 // ----------------------------------------------------------------------------
 
       
  1802 //
 
       
  1803 void CMmPhoneMessHandler::CallForwFlagsCachingCompleted( TUint aError )
 
       
  1804     {
 
       
  1805     iInternalRefreshFiles ^= KRefreshCallForwardingFlags;
 
       
  1806 
       
  1807     if ( UICC_STATUS_OK == aError )
 
       
  1808         {
 
       
  1809 TFLOGSTRING("TSY: CMmPhoneMessHandler::CallForwFlagsCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");
 
       
  1810 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_CALLFORWFLAGSCACHINGCOMPLETED, "CMmPhoneMessHandler::CallForwFlagsCachingCompleted: nokiatsy refresh successfully completed" );
 
       
  1811         UiccRefreshReq( UICC_REFRESH_DONE );
 
       
  1812         }
 
       
  1813     else
 
       
  1814         {
 
       
  1815 TFLOGSTRING2("TSY: CMmPhoneMessHandler::CallForwFlagsCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);
 
       
  1816 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_CALLFORWFLAGSCACHINGCOMPLETED, "CMmPhoneMessHandler::CallForwFlagsCachingCompleted: nokiatsy refresh completed with error" );
 
       
  1817         UiccRefreshReq( UICC_REFRESH_NOT_OK );
 
       
  1818         }
 
       
  1819     }
 
       
  1820 
       
  1821 // ----------------------------------------------------------------------------
 
       
  1822 // CMmPhoneMessHandler::OplRulesCachingCompleted
 
       
  1823 // Checks if "Refresh Done" will be sent to UICC.
 
       
  1824 // ----------------------------------------------------------------------------
 
       
  1825 //
 
       
  1826 TBool CMmPhoneMessHandler::OplRulesCachingCompleted( TInt aError )
 
       
  1827     {
 
       
  1828     // Initialize OPL refresh ongoing value.
 
       
  1829     TBool oplRefreshOngoing( EFalse );
 
       
  1830 
       
  1831     // Check if refresh is ongoing.
 
       
  1832     if ( iInternalRefreshFiles & KRefreshOplRules )
 
       
  1833         {
 
       
  1834         iInternalRefreshFiles ^= KRefreshOplRules;
 
       
  1835 
       
  1836         oplRefreshOngoing = ETrue;
 
       
  1837 
       
  1838         if ( KErrNone == aError )
 
       
  1839             {
 
       
  1840 TFLOGSTRING("TSY: CMmPhoneMessHandler::OplRulesCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");
 
       
  1841 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_OPLRULESCACHINGCOMPLETED, "CMmPhoneMessHandler::OplRulesCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE" );
 
       
  1842             UiccRefreshReq( UICC_REFRESH_DONE );
 
       
  1843             }
 
       
  1844         else
 
       
  1845             {
 
       
  1846 TFLOGSTRING2("TSY: CMmPhoneMessHandler::OplRulesCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);
 
       
  1847 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_OPLRULESCACHINGCOMPLETED, "CMmPhoneMessHandler::OplRulesCachingCompleted: nokiatsy refresh completed with error" );
 
       
  1848             UiccRefreshReq( UICC_REFRESH_NOT_OK );
 
       
  1849             }
 
       
  1850         }
 
       
  1851 
       
  1852     return oplRefreshOngoing;
 
       
  1853     }
 
       
  1854 
       
  1855 // ----------------------------------------------------------------------------
 
       
  1856 // CMmPhoneMessHandler::PnnRecordCachingCompleted
 
       
  1857 // Checks if "Refresh Done" will be sent to UICC.
 
       
  1858 // ----------------------------------------------------------------------------
 
       
  1859 //
 
       
  1860 void CMmPhoneMessHandler::PnnRecordCachingCompleted( TUint8 aError )
 
       
  1861     {
 
       
  1862     // Check if refresh is ongoing.
 
       
  1863     if ( iInternalRefreshFiles & KRefreshPnnRecord )
 
       
  1864         {
 
       
  1865         iInternalRefreshFiles ^= KRefreshPnnRecord;
 
       
  1866 
       
  1867         if ( UICC_STATUS_OK == aError )
 
       
  1868             {
 
       
  1869 TFLOGSTRING("TSY: CMmPhoneMessHandler::PnnRecordCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");
 
       
  1870 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_PNNRECORDCACHINGCOMPLETED, "CMmPhoneMessHandler::PnnRecordCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE" );
 
       
  1871             UiccRefreshReq( UICC_REFRESH_DONE );
 
       
  1872             }
 
       
  1873         else
 
       
  1874             {
 
       
  1875 TFLOGSTRING2("TSY: CMmPhoneMessHandler::PnnRecordCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);
 
       
  1876 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_PNNRECORDCACHINGCOMPLETED, "CMmPhoneMessHandler::PnnRecordCachingCompleted: nokiatsy refresh completed with error" );
 
       
  1877             UiccRefreshReq( UICC_REFRESH_NOT_OK );
 
       
  1878             }
 
       
  1879         }
 
       
  1880     }
 
       
  1881 
       
  1882 // ----------------------------------------------------------------------------
 
       
  1883 // CMmPhoneMessHandler::OnsNameCachingCompleted
 
       
  1884 // Checks if "Refresh Done" will be sent to SIMSON.
 
       
  1885 // ----------------------------------------------------------------------------
 
       
  1886 //
 
       
  1887 void CMmPhoneMessHandler::OnsNameCachingCompleted( TUint8 aError )
 
       
  1888     {
 
       
  1889     // Check if refresh is ongoing.
 
       
  1890     if ( iInternalRefreshFiles & KRefreshOnsName )
 
       
  1891         {
 
       
  1892         iInternalRefreshFiles ^= KRefreshOnsName;
 
       
  1893 
       
  1894         if ( UICC_STATUS_OK == aError )
 
       
  1895             {
 
       
  1896 TFLOGSTRING("TSY: CMmPhoneMessHandler::OnsNameCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE");
 
       
  1897 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_ONSNAMECACHINGCOMPLETED, "CMmPhoneMessHandler::OnsNameCachingCompleted: nokiatsy refresh successfully completed ==> REFRESH_DONE" );
 
       
  1898             UiccRefreshReq( UICC_REFRESH_DONE );
 
       
  1899             }
 
       
  1900         else
 
       
  1901             {
 
       
  1902 TFLOGSTRING2("TSY: CMmPhoneMessHandler::OnsNameCachingCompleted: nokiatsy refresh completed with error %d ==> REFRESH_DONE", aError);
 
       
  1903 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_ONSNAMECACHINGCOMPLETED, "CMmPhoneMessHandler::OnsNameCachingCompleted: nokiatsy refresh completed with error" );
 
       
  1904             UiccRefreshReq( UICC_REFRESH_NOT_OK );
 
       
  1905             }
 
       
  1906         }
 
       
  1907     }
 
       
  1908 
       
  1909 // ----------------------------------------------------------------------------
 
       
  1910 // CMmPhoneMessHandler::UiccReadEfEstReq
 
       
  1911 // reads EFest
 
       
  1912 // ----------------------------------------------------------------------------
 
       
  1913 //
 
       
  1914 TInt CMmPhoneMessHandler::UiccReadEfEstReq()
 
       
  1915     {
 
       
  1916 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadEfEstReq");
 
       
  1917 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCREADEFESTREQ, "CMmPhoneMessHandler::UiccReadEfEstReq" );
 
       
  1918 
       
  1919     TInt ret( KErrNone );
 
       
  1920 
       
  1921     if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() &&
 
       
  1922         iMmUiccMessHandler->GetServiceStatus( KServiceAcl ) )
 
       
  1923         {
 
       
  1924         // Set parameters for UICC_APPL_CMD_REQ message
 
       
  1925         TUiccReadTransparent params;
 
       
  1926         params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 
       
  1927         params.trId = ETrIdAclStatusReadEfEst;
 
       
  1928         params.dataAmount = 0;
 
       
  1929         params.dataOffset = 0;
 
       
  1930         params.fileId = KElemEst;
 
       
  1931         params.fileIdSfi = 0x05;
 
       
  1932         params.serviceType = UICC_APPL_READ_TRANSPARENT;
 
       
  1933 
       
  1934         // File id path
 
       
  1935         params.filePath.Append( KMasterFileId >> 8 );
 
       
  1936         params.filePath.Append( KMasterFileId );
 
       
  1937         params.filePath.Append( iMmUiccMessHandler->GetApplicationFileId() );
 
       
  1938 
       
  1939         ret = iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 
       
  1940         }
 
       
  1941     else
 
       
  1942         {
 
       
  1943 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadEfEstReq: card type is NOT UICC or ACL not supported in EFust");
 
       
  1944 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_UICCREADEFESTREQ, "CMmPhoneMessHandler::UiccReadEfEstReq: card type is NOT UICC or ACL not supported in EFust" );
 
       
  1945         iACLIsProgress = EFalse;
 
       
  1946         ret = KErrNotFound;
 
       
  1947         }
 
       
  1948     return ret;
 
       
  1949     }
 
       
  1950 
       
  1951 // ----------------------------------------------------------------------------
 
       
  1952 // CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp
 
       
  1953 // Handles EFest read response in case of getting ACL status
 
       
  1954 // ----------------------------------------------------------------------------
 
       
  1955 //
 
       
  1956 void CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp(
 
       
  1957     TInt aStatus,
 
       
  1958     const TDesC8& aFileData )
 
       
  1959     {
 
       
  1960 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp");
 
       
  1961 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCGETACLSTATUSREADEFESTRESP, "CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp" );
 
       
  1962 
       
  1963     TInt ret( KErrNone );
 
       
  1964     RMobilePhone::TAPNControlListServiceStatus aclStatus;
 
       
  1965 
       
  1966     if( UICC_STATUS_OK == aStatus )
 
       
  1967         {
 
       
  1968         TUint8 aclState( aFileData[0] & KAclStateMask );
 
       
  1969         if( aclState )
 
       
  1970             {
 
       
  1971             aclStatus = RMobilePhone::EAPNControlListServiceEnabled;
 
       
  1972             }
 
       
  1973         else
 
       
  1974             {
 
       
  1975             aclStatus = RMobilePhone::EAPNControlListServiceDisabled;
 
       
  1976             }
 
       
  1977         }
 
       
  1978     else
 
       
  1979         {
 
       
  1980 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp: EFest reading failed: 0x%x", aStatus);
 
       
  1981 OstTrace1( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_UICCGETACLSTATUSREADEFESTRESP, "CMmPhoneMessHandler::UiccGetAclStatusReadEfEstResp: EFest reading failed: 0x%x", aStatus );
 
       
  1982         ret = KErrAccessDenied;
 
       
  1983         }
 
       
  1984 
       
  1985     // complete with packed parameter
 
       
  1986     CMmDataPackage dataPackage;
 
       
  1987 
       
  1988     if( KErrNone == ret )
 
       
  1989         {
 
       
  1990         dataPackage.PackData( &aclStatus );
 
       
  1991         }
 
       
  1992 
       
  1993     iACLIsProgress = EFalse; //set ACL flag
 
       
  1994     iMessageRouter->Complete(
 
       
  1995         EMobilePhoneGetAPNControlListServiceStatus,
 
       
  1996         &dataPackage,
 
       
  1997         ret );
 
       
  1998     }
 
       
  1999 
       
  2000 // ----------------------------------------------------------------------------
 
       
  2001 // CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp
 
       
  2002 // Handles EFest read response in case of setting ACL status
 
       
  2003 // ----------------------------------------------------------------------------
 
       
  2004 //
 
       
  2005 void CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp(
 
       
  2006     TInt aStatus,
 
       
  2007     const TDesC8& aFileData )
 
       
  2008     {
 
       
  2009 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp");
 
       
  2010 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCSETACLSTATUSREADEFESTRESP, "CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp" );
 
       
  2011 
       
  2012     TInt ret( KErrNone );
 
       
  2013     TBool completeNeeded( ETrue );
 
       
  2014 
       
  2015     if( UICC_STATUS_OK == aStatus )
 
       
  2016         {
 
       
  2017         TUint8 aclState( aFileData[0] );
 
       
  2018         if( aclState & KAclStateMask )
 
       
  2019             {
 
       
  2020             if( RMobilePhone::EAPNControlListServiceDisabled == iAclStatus )
 
       
  2021                 {
 
       
  2022                 // ACL state is enabled and we need to set it to disabled .
 
       
  2023                 // So EFest needs to be updated
 
       
  2024                 completeNeeded = EFalse;
 
       
  2025                 UiccSetAclStatusWriteEfEstReq( aclState );
 
       
  2026                 }
 
       
  2027             else
 
       
  2028                 {
 
       
  2029                 // ACL status already correct, let's complete
 
       
  2030 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: ACL status already correct, let's complete");
 
       
  2031 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_UICCSETACLSTATUSREADEFESTRESP, "CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: ACL status already correct, let's complete" );
 
       
  2032                 }
 
       
  2033             }
 
       
  2034         else
 
       
  2035             {
 
       
  2036             if( RMobilePhone::EAPNControlListServiceEnabled == iAclStatus )
 
       
  2037                 {
 
       
  2038                 // EFest needs to be updated
 
       
  2039                 completeNeeded = EFalse;
 
       
  2040                 UiccSetAclStatusWriteEfEstReq( aclState );
 
       
  2041                 }
 
       
  2042             else
 
       
  2043                 {
 
       
  2044                 // ACL status already correct, let's complete
 
       
  2045 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: ACL status already correct, let's complete");
 
       
  2046 OstTrace0( TRACE_NORMAL, DUP2_CMMPHONEMESSHANDLER_UICCSETACLSTATUSREADEFESTRESP, "CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: ACL status already correct, let's complete" );
 
       
  2047                 }
 
       
  2048             }
 
       
  2049         }
 
       
  2050     else
 
       
  2051         {
 
       
  2052         // EFest reading failed
 
       
  2053 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: EFest reading failed: 0x%x", aStatus );
 
       
  2054 OstTrace1( TRACE_NORMAL, DUP3_CMMPHONEMESSHANDLER_UICCSETACLSTATUSREADEFESTRESP, "CMmPhoneMessHandler::UiccSetAclStatusReadEfEstResp: EFest reading failed: 0x%x", aStatus );
 
       
  2055         ret = KErrAccessDenied;
 
       
  2056         }
 
       
  2057 
       
  2058     if( completeNeeded )
 
       
  2059         {
 
       
  2060         // set flag and complete
 
       
  2061         iACLIsProgress = EFalse; //set ACL flag
 
       
  2062         iMessageRouter->Complete(
 
       
  2063             EMobilePhoneSetAPNControlListServiceStatus,
 
       
  2064             ret );
 
       
  2065         }
 
       
  2066     }
 
       
  2067 
       
  2068 // ----------------------------------------------------------------------------
 
       
  2069 // CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq
 
       
  2070 // Writes ACL status to EFest
 
       
  2071 // ----------------------------------------------------------------------------
 
       
  2072 //
 
       
  2073 TInt CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq(  TUint8 aOldAclState )
 
       
  2074     {
 
       
  2075 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq");
 
       
  2076 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCSETACLSTATUSWRITEEFESTREQ, "CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq" );
 
       
  2077 
       
  2078     TInt ret( KErrNone );
 
       
  2079     TUint8 newState;
 
       
  2080     if( RMobilePhone::EAPNControlListServiceDisabled == iAclStatus )
 
       
  2081         {
 
       
  2082         // ACL status is going to be disabled and status is in 3rd
 
       
  2083         // bit of 1st byte, so let's set 3rd bit in 1st byte to 0
 
       
  2084         newState = aOldAclState & 0xFB;
 
       
  2085         }
 
       
  2086     else
 
       
  2087         {
 
       
  2088         // ACL status is going to be enabled and status is in 3rd
 
       
  2089         // bit of 1st byte, so let's set 3rd bit in 1st byte to 1
 
       
  2090         newState = aOldAclState + 0x04;
 
       
  2091         }
 
       
  2092 
       
  2093     if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() &&
 
       
  2094         iMmUiccMessHandler->GetServiceStatus( KServiceAcl ) )
 
       
  2095         {
 
       
  2096         TUiccWriteTransparent params;
 
       
  2097         params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 
       
  2098         params.trId = ETrIdAclStatusWriteEfEst;
 
       
  2099         params.dataOffset = 0;
 
       
  2100         params.dataAmount = 1; // only one byte is update
 
       
  2101         params.fileId = KElemEst;
 
       
  2102         params.fileIdSfi = 0x05;
 
       
  2103         params.serviceType = UICC_APPL_UPDATE_TRANSPARENT;
 
       
  2104         // File id path
 
       
  2105         params.filePath.Append( KMasterFileId >> 8 );
 
       
  2106         params.filePath.Append( KMasterFileId );
 
       
  2107         params.filePath.Append( iMmUiccMessHandler->GetApplicationFileId() );
 
       
  2108         params.fileData.Append( newState );
 
       
  2109 
       
  2110         ret = iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 
       
  2111         }
 
       
  2112     else
 
       
  2113         {
 
       
  2114 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq: card type is NOT UICC or ACL not supported in EFust");
 
       
  2115 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_UICCSETACLSTATUSWRITEEFESTREQ, "CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstReq: card type is NOT UICC or ACL not supported in EFust" );
 
       
  2116         iACLIsProgress = EFalse;
 
       
  2117         ret = KErrGeneral;
 
       
  2118         }
 
       
  2119     return ret;
 
       
  2120     }
 
       
  2121 
       
  2122 // ----------------------------------------------------------------------------
 
       
  2123 // CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp
 
       
  2124 // Handles EFest write response in case of setting ACL status
 
       
  2125 // ----------------------------------------------------------------------------
 
       
  2126 //
 
       
  2127 void CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp(
 
       
  2128     TInt aStatus )
 
       
  2129     {
 
       
  2130 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp");
 
       
  2131 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCSETACLSTATUSWRITEEFESTRESP, "CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp" );
 
       
  2132     TInt ret( KErrAccessDenied );
 
       
  2133 
       
  2134     if( UICC_STATUS_OK == aStatus )
 
       
  2135         {
 
       
  2136         ret = KErrNone;
 
       
  2137         }
 
       
  2138     else
 
       
  2139         {
 
       
  2140 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp: writing failed: 0x%x", aStatus);
 
       
  2141 OstTrace1( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_UICCSETACLSTATUSWRITEEFESTRESP, "CMmPhoneMessHandler::UiccSetAclStatusWriteEfEstResp: writing failed: 0x%x", aStatus );
 
       
  2142         }
 
       
  2143 
       
  2144     iACLIsProgress = EFalse; //set ACL flag
 
       
  2145     iMessageRouter->Complete(
 
       
  2146         EMobilePhoneSetAPNControlListServiceStatus,
 
       
  2147         ret );
 
       
  2148 
       
  2149     if ( KErrNone == ret )
 
       
  2150         {
 
       
  2151         iMessageRouter->Complete(
 
       
  2152             EMobilePhoneNotifyAPNControlListServiceStatusChange,
 
       
  2153             KErrNone );
 
       
  2154         }
 
       
  2155     }
 
       
  2156 
       
  2157 // ----------------------------------------------------------------------------
 
       
  2158 // CMmPhoneMessHandler::UiccReadAclReq
 
       
  2159 // reads ACL list from EFacl
 
       
  2160 // ----------------------------------------------------------------------------
 
       
  2161 //
 
       
  2162 TInt CMmPhoneMessHandler::UiccReadAclReq()
 
       
  2163     {
 
       
  2164 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadAclReq");
 
       
  2165 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCREADACLREQ, "CMmPhoneMessHandler::UiccReadAclReq" );
 
       
  2166 
       
  2167     TInt ret( KErrNone );
 
       
  2168 
       
  2169     if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() &&
 
       
  2170         iMmUiccMessHandler->GetServiceStatus( KServiceAcl ) )
 
       
  2171         {
 
       
  2172         // Set parameters for UICC_APPL_CMD_REQ message
 
       
  2173         TUiccReadTransparent params;
 
       
  2174         params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 
       
  2175         params.trId = ETrIdAclReadEfAcl;
 
       
  2176         params.dataAmount = 0;
 
       
  2177         params.dataOffset = 0;
 
       
  2178         params.fileId = KElemFileAcl;
 
       
  2179         params.fileIdSfi = UICC_SFI_NOT_PRESENT;
 
       
  2180         params.serviceType = UICC_APPL_READ_TRANSPARENT;
 
       
  2181 
       
  2182         // File id path
 
       
  2183         params.filePath.Append( KMasterFileId >> 8 );
 
       
  2184         params.filePath.Append( KMasterFileId );
 
       
  2185         params.filePath.Append( iMmUiccMessHandler->GetApplicationFileId() );
 
       
  2186 
       
  2187         ret = iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 
       
  2188         }
 
       
  2189     else
 
       
  2190         {
 
       
  2191 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadAclReq: card type is NOT UICC or ACL not supported in EFust");
 
       
  2192 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_UICCREADACLREQ, "CMmPhoneMessHandler::UiccReadAclReq: card type is NOT UICC or ACL not supported in EFust" );
 
       
  2193         iACLIsProgress = EFalse;
 
       
  2194         ret = KErrNotFound;
 
       
  2195         }
 
       
  2196 
       
  2197     return ret;
 
       
  2198     }
 
       
  2199 
       
  2200 // ----------------------------------------------------------------------------
 
       
  2201 // CMmPhoneMessHandler::UiccReadAclResp
 
       
  2202 // Handles response for ACL list reading from EFacl
 
       
  2203 // ----------------------------------------------------------------------------
 
       
  2204 //
 
       
  2205 void CMmPhoneMessHandler::UiccReadAclResp(
 
       
  2206     TInt aStatus,
 
       
  2207     const TDesC8& aFileData )
 
       
  2208     {
 
       
  2209 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccReadAclResp");
 
       
  2210 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCREADACLRESP, "CMmPhoneMessHandler::UiccReadAclResp" );
 
       
  2211     TInt ret( KErrNone );
 
       
  2212     if( UICC_STATUS_OK == aStatus )
 
       
  2213         {
 
       
  2214         if( iAPNList )
 
       
  2215             {
 
       
  2216             delete iAPNList;
 
       
  2217             iAPNList = 0;
 
       
  2218             }
 
       
  2219 
       
  2220         TPtrC8 dataPoint;
 
       
  2221         dataPoint.Set( &aFileData[KApnDataIndex], aFileData.Length() - 1 );
 
       
  2222         iAPNList = DecodeACL( dataPoint, aFileData[KNumOfApnsIndex] );
 
       
  2223 
       
  2224         switch( iOngoingAclIpc )
 
       
  2225             {
 
       
  2226             case EMobilePhoneEnumerateAPNEntries:
 
       
  2227                 {
 
       
  2228                 CompleteEnumerateAPNEntries();
 
       
  2229                 break;
 
       
  2230                 }
 
       
  2231             case EMobilePhoneGetAPNname:
 
       
  2232                 {
 
       
  2233                 CompleteGetAPNName( iAPNReadOrDeleteIndex );
 
       
  2234                 break;
 
       
  2235                 }
 
       
  2236             case EMobilePhoneDeleteAPNName:
 
       
  2237                 {
 
       
  2238                 ret = UiccDeleteApnEntry( iAPNReadOrDeleteIndex );
 
       
  2239                 break;
 
       
  2240                 }
 
       
  2241             case EMobilePhoneAppendAPNName:
 
       
  2242                 {
 
       
  2243                 iAPNList->AppendL( iAPNDataBuffer.iApn );
 
       
  2244                 ret = UiccWriteEfAclReq();
 
       
  2245                 break;
 
       
  2246                 }
 
       
  2247             default:
 
       
  2248                 {
 
       
  2249 TFLOGSTRING2( "TSY: CMmPhoneMessHandler::UiccReadAclResp: unknown IPC (%d)", iOngoingAclIpc );
 
       
  2250 OstTrace1( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_UICCREADACLRESP, "CMmPhoneMessHandler::UiccReadAclResp: unknown IPC (%d)", iOngoingAclIpc );
 
       
  2251                 iACLIsProgress = EFalse;
 
       
  2252                 break;
 
       
  2253                 }
 
       
  2254             }
 
       
  2255         }
 
       
  2256     else
 
       
  2257         {
 
       
  2258 TFLOGSTRING2("TSY: CMmPhoneMessHandler::UiccReadAclResp: reading failed: 0x%x", aStatus);
 
       
  2259 OstTrace1( TRACE_NORMAL, DUP2_CMMPHONEMESSHANDLER_UICCREADACLRESP, "CMmPhoneMessHandler::UiccReadAclResp: reading failed: 0x%x", aStatus );
 
       
  2260         ret = KErrAccessDenied;
 
       
  2261         }
 
       
  2262 
       
  2263     if( KErrNone != ret )
 
       
  2264         {
 
       
  2265         iACLIsProgress = EFalse;
 
       
  2266         iMessageRouter->Complete( iOngoingAclIpc, ret );
 
       
  2267         }
 
       
  2268     }
 
       
  2269 
       
  2270 // --------------------------------------------------------------------------
 
       
  2271 // CMmPhoneMessHandler::DecodeACL
 
       
  2272 // Encrypt from ACL to CDesC8ArrayFlat
 
       
  2273 // --------------------------------------------------------------------------
 
       
  2274 //
 
       
  2275 CDesC8ArrayFlat* CMmPhoneMessHandler::DecodeACL
 
       
  2276         (
 
       
  2277         const TDesC8& aTlv,
 
       
  2278         TInt aTotalEntries
 
       
  2279         ) const
 
       
  2280     {
 
       
  2281 TFLOGSTRING2("TSY: CMmPhoneMessHandler::DecodeACL. Number of total entries: %d", aTotalEntries);
 
       
  2282 OstTrace1( TRACE_NORMAL, CMMPHONEMESSHANDLER_DECODEACL, "CMmPhoneMessHandler::DecodeACL. Number of total entries: %d", aTotalEntries );
 
       
  2283 
       
  2284     // allocate new array, 1 is granularity
 
       
  2285     CDesC8ArrayFlat* apnList = new( ELeave ) CDesC8ArrayFlat( 1 );
 
       
  2286     CleanupStack::PushL( apnList );
 
       
  2287 
       
  2288     TInt offset( 0 );
 
       
  2289 
       
  2290     //check length before using
 
       
  2291     if ( 0 < aTlv.Length() )
 
       
  2292         {
 
       
  2293         // decode TLV entries to CDesC8ArrayFlat
 
       
  2294         for ( TInt i = 0; i < aTotalEntries; i++ )
 
       
  2295             {
 
       
  2296             TInt tag( aTlv[offset++] );
 
       
  2297 
       
  2298             // spec: The tag value of the APN-TLV shall be 'DD'
 
       
  2299             TF_ASSERT( tag == 0xdd );
 
       
  2300 
       
  2301             TInt len( aTlv[offset++] );
 
       
  2302             TF_ASSERT( len <= 100 );   // spec: APN max length is 100
 
       
  2303 
       
  2304             TPtrC8 data = aTlv.Mid( offset, len );
 
       
  2305             apnList->InsertL( i, data );
 
       
  2306 
       
  2307             offset += len; // advance to next TLV
 
       
  2308             }
 
       
  2309         }
 
       
  2310 
       
  2311     CleanupStack::Pop( apnList );
 
       
  2312     return apnList;
 
       
  2313     }
 
       
  2314 
       
  2315 // --------------------------------------------------------------------------
 
       
  2316 // CMmPhoneMessHandler::CompleteEnumerateAPNEntries
 
       
  2317 // send number of ACL index to the client.
 
       
  2318 // --------------------------------------------------------------------------
 
       
  2319 //
 
       
  2320 void CMmPhoneMessHandler::CompleteEnumerateAPNEntries()
 
       
  2321     {
 
       
  2322     TInt indexCount( iAPNList->MdcaCount() );
 
       
  2323 TFLOGSTRING2("TSY: CMmPhoneMessHandler::CompleteEnumerateAPNEntries. Number of APN's: %d",indexCount);
 
       
  2324 OstTrace1( TRACE_NORMAL, CMMPHONEMESSHANDLER_COMPLETEENUMERATEAPNENTRIES, "CMmPhoneMessHandler::CompleteEnumerateAPNEntries. Number of APN's: %d", indexCount );
 
       
  2325 
       
  2326     //package index of TLV's to the client
 
       
  2327     CMmDataPackage dataPackage;
 
       
  2328     dataPackage.PackData( &indexCount );
 
       
  2329 
       
  2330     // set flag and complete
 
       
  2331     iACLIsProgress = EFalse; //set ACL flag
 
       
  2332     iMessageRouter->Complete(
 
       
  2333         EMobilePhoneEnumerateAPNEntries,
 
       
  2334         &dataPackage,
 
       
  2335         KErrNone );
 
       
  2336     }
 
       
  2337 
       
  2338 // --------------------------------------------------------------------------
 
       
  2339 // CMmPhoneMessHandler::CompleteGetAPNName
 
       
  2340 // send APN name to the client.
 
       
  2341 // --------------------------------------------------------------------------
 
       
  2342 //
 
       
  2343 void CMmPhoneMessHandler::CompleteGetAPNName( TUint8 aIndex )
 
       
  2344     {
 
       
  2345 TFLOGSTRING("TSY: CMmPhoneMessHandler::CompleteGetAPNName ");
 
       
  2346 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_COMPLETEGETAPNNAME, "CMmPhoneMessHandler::CompleteGetAPNName" );
 
       
  2347 
       
  2348     CMmDataPackage dataPackage;
 
       
  2349     RMobilePhone::TAPNEntryV3 aclEntry;
 
       
  2350     TInt err( KErrNone );
 
       
  2351 
       
  2352     //check if index is valid or not.
 
       
  2353     if ( iAPNList->MdcaCount() <= aIndex )
 
       
  2354         {
 
       
  2355         err = KErrOverflow;
 
       
  2356         }
 
       
  2357     else
 
       
  2358         {
 
       
  2359 TFLOGSTRING2("TSY: CMmPhoneMessHandler::CompleteGetAPNName. Copy entry from index %d",aIndex);
 
       
  2360 OstTrace1( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_COMPLETEGETAPNNAME, "CMmPhoneMessHandler::CompleteGetAPNName. Copy entry from index %d", aIndex );
 
       
  2361         aclEntry.iApn.Copy( iAPNList->MdcaPoint( aIndex ) );
 
       
  2362         }
 
       
  2363 
       
  2364     dataPackage.PackData( &aclEntry );
 
       
  2365 
       
  2366     // set flag and complete
 
       
  2367     iACLIsProgress = EFalse; //set ACL flag
 
       
  2368     iMessageRouter->Complete( EMobilePhoneGetAPNname, &dataPackage, err );
 
       
  2369     }
 
       
  2370 
       
  2371 // --------------------------------------------------------------------------
 
       
  2372 // CMmPhoneMessHandler::UiccDeleteApnEntry
 
       
  2373 // Deletes APN entry from internal cache and writes the change to EFacl
 
       
  2374 // --------------------------------------------------------------------------
 
       
  2375 //
 
       
  2376 TInt CMmPhoneMessHandler::UiccDeleteApnEntry( TInt aIndex )
 
       
  2377     {
 
       
  2378 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccDeleteApnEntry ");
 
       
  2379 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCDELETEAPNENTRY, "CMmPhoneMessHandler::UiccDeleteApnEntry" );
 
       
  2380 
       
  2381     TInt ret;
 
       
  2382     //check if aIndex is valid or not.
 
       
  2383     if ( iAPNList->MdcaCount() <= aIndex )
 
       
  2384         {
 
       
  2385         //error occurs
 
       
  2386         ret = KErrOverflow;
 
       
  2387         }
 
       
  2388     else
 
       
  2389         {
 
       
  2390         //data is valid
 
       
  2391         //delete data from cache
 
       
  2392         iAPNList->Delete( aIndex );
 
       
  2393         iAPNList->Compress();
 
       
  2394 
       
  2395         //write new list to the SIM
 
       
  2396         ret = UiccWriteEfAclReq();
 
       
  2397         }
 
       
  2398     return ret;
 
       
  2399     }
 
       
  2400 
       
  2401 // --------------------------------------------------------------------------
 
       
  2402 // CMmPhoneMessHandler::UiccWriteEfAclReq
 
       
  2403 // Writes APN entries from internal cache to the EFAcl
 
       
  2404 // --------------------------------------------------------------------------
 
       
  2405 //
 
       
  2406 TInt CMmPhoneMessHandler::UiccWriteEfAclReq()
 
       
  2407     {
 
       
  2408 TFLOGSTRING( "TSY: CMmPhoneMessHandler::UiccWriteEfAclReq" );
 
       
  2409 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCWRITEEFACLREQ, "CMmPhoneMessHandler::UiccWriteEfAclReq" );
 
       
  2410 
       
  2411     TInt ret( KErrNone );
 
       
  2412 
       
  2413     if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() &&
 
       
  2414         iMmUiccMessHandler->GetServiceStatus( KServiceAcl ) )
 
       
  2415         {
 
       
  2416         TInt dataLen( ACLLength( iAPNList ) );
 
       
  2417         TUint8 apnCount( iAPNList->MdcaCount() );
 
       
  2418 
       
  2419         TUiccWriteTransparent params;
 
       
  2420         params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 
       
  2421         params.trId = ETrIdAclWriteEfAcl;
 
       
  2422         params.dataOffset = 0;
 
       
  2423         params.dataAmount = dataLen;
 
       
  2424         params.fileId = KElemFileAcl;
 
       
  2425         params.fileIdSfi = UICC_SFI_NOT_PRESENT;
 
       
  2426         params.serviceType = UICC_APPL_UPDATE_TRANSPARENT;
 
       
  2427         // File id path
 
       
  2428         params.filePath.Append( KMasterFileId >> 8 );
 
       
  2429         params.filePath.Append( KMasterFileId );
 
       
  2430         params.filePath.Append( iMmUiccMessHandler->GetApplicationFileId() );
 
       
  2431 
       
  2432         params.fileData.Append( apnCount );
 
       
  2433         for ( TInt i = 0; i < apnCount; i++ )
 
       
  2434             {
 
       
  2435             TPtrC8 apn = iAPNList->MdcaPoint( i );
 
       
  2436             // spec: The tag value of the APN-TLV shall be 'DD'
 
       
  2437             params.fileData.Append( 0xdd );
 
       
  2438             params.fileData.Append( apn.Length() );
 
       
  2439             params.fileData.Append( apn );
 
       
  2440             }
 
       
  2441 
       
  2442         ret = iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 
       
  2443         }
 
       
  2444     else
 
       
  2445         {
 
       
  2446 TFLOGSTRING("TSY: CMmPhoneMessHandler::UiccWriteEfAclReq: card type is NOT UICC or ACL not supported in EFust");
 
       
  2447 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_UICCWRITEEFACLREQ, "CMmPhoneMessHandler::UiccWriteEfAclReq: card type is NOT UICC or ACL not supported in EFust" );
 
       
  2448         iACLIsProgress = EFalse;
 
       
  2449         ret = KErrNotFound;
 
       
  2450         }
 
       
  2451     return ret;
 
       
  2452     }
 
       
  2453 
       
  2454 // --------------------------------------------------------------------------
 
       
  2455 // CMmPhoneMessHandler::UiccWriteEfAclResp
 
       
  2456 // Handles response for EFAcl writing
 
       
  2457 // --------------------------------------------------------------------------
 
       
  2458 //
 
       
  2459 void CMmPhoneMessHandler::UiccWriteEfAclResp( TInt aStatus )
 
       
  2460     {
 
       
  2461 TFLOGSTRING( "TSY: CMmPhoneMessHandler::UiccWriteEfAclResp" );
 
       
  2462 OstTrace0( TRACE_NORMAL, CMMPHONEMESSHANDLER_UICCWRITEEFACLRESP, "CMmPhoneMessHandler::UiccWriteEfAclResp" );
 
       
  2463 
       
  2464     TInt ret( KErrNone );
 
       
  2465     if( UICC_STATUS_OK != aStatus )
 
       
  2466         {
 
       
  2467 TFLOGSTRING2( "TSY: CMmPhoneMessHandler::UiccWriteEfAclResp: EFacl writing failed: 0x%x", aStatus );
 
       
  2468 OstTrace1( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_UICCWRITEEFACLRESP, "CMmPhoneMessHandler::UiccWriteEfAclResp: EFacl writing failed: 0x%x", aStatus );
 
       
  2469 
       
  2470         ret = KErrAccessDenied;
 
       
  2471         }
 
       
  2472 
       
  2473     iACLIsProgress = EFalse; //set ACL flag
 
       
  2474     iMessageRouter->Complete(
 
       
  2475         iOngoingAclIpc,
 
       
  2476         ret );
 
       
  2477     }
 
       
  2478 
       
  2479 // --------------------------------------------------------------------------
 
       
  2480 // CMmPhoneMessHandler::ACLLength
 
       
  2481 // calculate total length of ACL
 
       
  2482 // --------------------------------------------------------------------------
 
       
  2483 //
 
       
  2484 TUint16 CMmPhoneMessHandler::ACLLength( CDesC8ArrayFlat* aApnList ) const
 
       
  2485     {
 
       
  2486 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ACLLength. Count: %d", aApnList->MdcaCount());
 
       
  2487 OstTrace1( TRACE_NORMAL, CMMPHONEMESSHANDLER_ACLLENGTH, "CMmPhoneMessHandler::ACLLength. Count: %d", aApnList->MdcaCount() );
 
       
  2488 
       
  2489     TUint16 length( 0 );
 
       
  2490 
       
  2491     for ( TInt i = 0; i < aApnList->MdcaCount(); i++ )
 
       
  2492         {
 
       
  2493         TPtrC8 apn = aApnList->MdcaPoint( i );
 
       
  2494         length += apn.Length() + 2;
 
       
  2495         }
 
       
  2496 
       
  2497     // result is incremented by one because of EFacl contains number of tlv objects
 
       
  2498     // as first byte of the file data
 
       
  2499     length++;
 
       
  2500 
       
  2501 TFLOGSTRING2("TSY: CMmPhoneMessHandler::ACLLength. ACL len: %d", length);
 
       
  2502 OstTrace1( TRACE_NORMAL, DUP1_CMMPHONEMESSHANDLER_ACLLENGTH, "CMmPhoneMessHandler::ACLLength. ACL len: %d", length );
 
       
  2503 
       
  2504     return length;
 
       
  2505     }
 
       
  2506 
  1217 // End of file
 
  2507 // End of file
FCL/sf/incubator/modemadaptation