1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   ?Description

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include <etelmm.h>

    20 #include <tisi.h>

    21 #include <pn_const.h>

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

    23 #include "cmmmessagerouter.h"

    24 #include "cmmphonebookoperationinit.h"

    25 #include "osttracedefinitions.h"

    26 #ifdef OST_TRACE_COMPILER_IN_USE

    27 #include "cmmphonebookoperationinittraces.h"

    28 #include "cmmphonebookoperationinit3G_adn.h"

    29 #endif

    30 

    31 // EXTERNAL DATA STRUCTURES

    32     // None

    33 

    34 // EXTERNAL FUNCTION PROTOTYPES

    35     // None

    36 

    37 // CONSTANTS

    38 

    39 // MACROS

    40     // None

    41 

    42 // LOCAL CONSTANTS AND MACROS

    43     // None

    44 

    45 // MODULE DATA STRUCTURES

    46     // None

    47 

    48 // LOCAL FUNCTION PROTOTYPES

    49     // None

    50 

    51 // ==================== LOCAL FUNCTIONS =====================================

    52     // None

    53 

    54 

    55 // ================= MEMBER FUNCTIONS =======================================

    56 

    57 // -----------------------------------------------------------------------------

    58 // CMmPhoneBookOperationInit::CMmPhoneBookOperationInit

    59 // C++ default constructor can NOT contain any code, that

    60 // might leave.

    61 // -----------------------------------------------------------------------------

    62 

    63 CMmPhoneBookOperationInit::CMmPhoneBookOperationInit

    64     (

    65     // None

    66     )

    67     {

    68     TFLOGSTRING("TSY: CmmPhonebookOperatorInit::CmmPhonebookOperatorInit");

    69 OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONINIT_CMMPHONEBOOKOPERATIONINIT, "CMmPhoneBookOperationInit::CMmPhoneBookOperationInit" );

    70     }

    71 

    72 // -----------------------------------------------------------------------------

    73 // CMmPhoneBookOperationInit::~CMmPhoneBookOperationInit

    74 // C++ destructor.

    75 // -----------------------------------------------------------------------------

    76 //

    77 CMmPhoneBookOperationInit::~CMmPhoneBookOperationInit

    78     (

    79     // None

    80     )

    81     {

    82     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::~CMmPhoneBookOperationInit");

    83 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONINIT_CMMPHONEBOOKOPERATIONINIT, "CMmPhoneBookOperationInit::~CMmPhoneBookOperationInit" );

    84     delete iPBStoreInfoData;

    85     }

    86 

    87 // -----------------------------------------------------------------------------

    88 // CmmPhonebookOperatorInit::NewL

    89 // Two-phased constructor.

    90 // Creates a new CmmPhonebookOperatorInit object instance.

    91 // -----------------------------------------------------------------------------

    92 

    93 CMmPhoneBookOperationInit* CMmPhoneBookOperationInit::NewL

    94     (

    95     CMmPhoneBookStoreMessHandler* aMmPhoneBookStoreMessHandler,

    96     CMmUiccMessHandler* aUiccMessHandler,

    97     const CMmDataPackage* aDataPackage // Data

    98     )

    99     {

   100     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::NewL");

   101     OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONINIT_NEWL, "CMmPhoneBookOperationInit::NewL" );

   102 

   103     TName phonebookTypeName;

   104 

   105     CMmPhoneBookOperationInit* mmPhoneBookOperationInit =

   106         new( ELeave ) CMmPhoneBookOperationInit();

   107 

   108     CleanupStack::PushL( mmPhoneBookOperationInit );

   109 

   110     const CPhoneBookDataPackage* phoneBookData =

   111         static_cast<const CPhoneBookDataPackage*>( aDataPackage );

   112 

   113     phoneBookData->GetPhoneBookName( phonebookTypeName );

   114     //Store phonebook name

   115     mmPhoneBookOperationInit->iPhonebookType = phonebookTypeName;

   116 

   117     if( 0 == phonebookTypeName.CompareF( KInternalPhoneBookType ) )

   118         {

   119         mmPhoneBookOperationInit->iIniPhase = EPBIniPhase_Internal;

   120         }

   121     else // Full construction is not needed in case of internal initilization

   122         {

   123         mmPhoneBookOperationInit->iTransactionId = ETrIdPbInit;

   124         mmPhoneBookOperationInit->ConstructL( );

   125         }

   126 

   127     mmPhoneBookOperationInit->iMmPhoneBookStoreMessHandler =

   128         aMmPhoneBookStoreMessHandler;

   129 

   130     mmPhoneBookOperationInit->iMmUiccMessHandler = aUiccMessHandler;

   131 

   132     // set to false by default. Will be set as true once after

   133     // initialization req has been generated.

   134     mmPhoneBookOperationInit->iInternalInit = EFalse;

   135 

   136     CleanupStack::Pop( mmPhoneBookOperationInit );

   137 

   138     return mmPhoneBookOperationInit;

   139     }

   140 

   141 // -----------------------------------------------------------------------------

   142 // CMmPhoneBookOperationInit::ConstructL

   143 // Initialises object attributes.

   144 // -----------------------------------------------------------------------------

   145 //

   146 void CMmPhoneBookOperationInit::ConstructL

   147     (

   148     )

   149     {

   150     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::ConstructL");

   151 OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONINIT_CONSTRUCTL, "CMmPhoneBookOperationInit::ConstructL" );

   152 

   153     iPBStoreInfoData = new( ELeave ) CStorageInfoData();

   154 

   155     iServiceType = 0;

   156     iNumOfPBRRecords = 0;

   157     iADNPbInitilized = EFalse;

   158 

   159 #ifdef INTERNAL_RD_USIM_PHONEBOOK_GAS_AND_AAS

   160     TFLOGSTRING("TSY: CMmPhoneBookStoreMessHandler. \

   161         INTERNAL_RD_USIM_PHONEBOOK_GAS_AND_AAS is ON.");

   162 

   163     iMmPhoneBookStoreMessHandler->SetMaxNumOfAasEntries( 0 );

   164     iMmPhoneBookStoreMessHandler->SetMaxNumberOfGAS( 0 );

   165 #else

   166     TFLOGSTRING("TSY: CMmPhoneBookStoreMessHandler. \

   167         INTERNAL_RD_USIM_PHONEBOOK_GAS_AND_AAS is OFF.");

   168 OstTrace0( TRACE_NORMAL, DUP4_CMMPHONEBOOKOPERATIONINIT_CONSTRUCTL, "CMmPhoneBookOperationInit::ConstructL, CASW_RD_USIM_PHONEBOOK_GAS_AND_AAS is OFF" );

   169 #endif // INTERNAL_RD_USIM_PHONEBOOK_GAS_AND_AAS

   170     }

   171 

   172 

   173 

   174 

   175 // TRANSMIT

   176 

   177 

   178 

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

   180 // CMmPhoneBookOperationInit::UICCCreateReq

   181 // Create Request for Phonebook initialization for SIM

   182 // -----------------------------------------------------------------------------

   183 //

   184 TInt CMmPhoneBookOperationInit::UICCCreateReq

   185     (

   186     TInt aIpc,

   187     const CMmDataPackage* /*aDataPackage*/

   188     )

   189     {

   190     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCCreateReq");

   191 OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONINIT_UICCCREATEREQ, "CMmPhoneBookOperationInit::UICCCreateReq" );

   192     TInt ret( KErrNotSupported );

   193 

   194     switch( aIpc )

   195         {

   196         case EMmTsyPhoneBookStoreInitIPC:

   197             {

   198             if( !iInternalInit )

   199                 {

   200                 // no internal init ongoing

   201                 if ( EPBIniPhase_Internal == iIniPhase )

   202                     {

   203                     // Initialization is starting. Turn the flag on.

   204                     iInternalInit = ETrue;

   205                     }

   206                 iServiceType = UICC_APPL_FILE_INFO;

   207                 iExtensionPresent = EFalse; // Default EXT File is not present

   208 

   209                 // Start Initialization for 2G phonebooks

   210                 // Check for ADN Phonebook is available and activated

   211                 if(iMmUiccMessHandler->GetServiceStatus( ICC_ADN_SERVICE_NUM))

   212                     {

   213                     iIniPhase = EPBInitPhaseADN;

   214                     }

   215                 else

   216                     {

   217                     iIniPhase = GetNextAvailablePbIcc(ICC_ADN_SERVICE_NUM);

   218                     }

   219                 ret = UICCInitializeReq();

   220                 }

   221             else  // else for if internalInit goign on

   222                 {

   223                 // Simultaneous initializations are not allowed.

   224                 ret = KErrInUse;

   225                 }

   226             break;

   227             }

   228         default:

   229             {

   230             // Nothing to do here

   231             TFLOGSTRING2("TSY: CMmPhoneBookOperationInit::UICCCreateReq - \

   232             Unknown IPC: %d", aIpc);

   233 OstTrace1( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONINIT_UICCCREATEREQ, "CMmPhoneBookOperationInit::UICCCreateReq;Unknowns aIpc=%d", aIpc );

   234             break;

   235             }

   236         } // switch-case ends

   237     return ret;

   238     }

   239 

   240 

   241 // -----------------------------------------------------------------------------

   242 // CmmPhonebookOperationInit::UICCInitializeReq

   243 // Creates phonebook initialize request data for SIM

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

   245 //

   246 TInt CMmPhoneBookOperationInit::UICCInitializeReq()

   247     {

   248 TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq");

   249 OstTrace0( TRACE_FATAL, CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq" );

   250 

   251         TInt ret( KErrNone );

   252         TInt appFileID ( APPL_FILE_ID );   // Application File id for DFphonebook

   253         TUiccReadLinearFixed cmdParams;

   254 

   255         cmdParams.messHandlerPtr =

   256             static_cast<MUiccOperationBase*>(iMmPhoneBookStoreMessHandler);

   257         cmdParams.trId = ETrIdPbInit;

   258 

   259         cmdParams.filePath.Append(static_cast<TUint8>( MF_FILE >> 8 ));

   260         cmdParams.filePath.Append(static_cast<TUint8>( MF_FILE ));

   261         cmdParams.filePath.Append(appFileID>>8);

   262         cmdParams.filePath.Append(appFileID);

   263         cmdParams.filePath.Append(static_cast<TUint8>( DF_PHONEBOOK >> 8 ));

   264         cmdParams.filePath.Append(static_cast<TUint8>( DF_PHONEBOOK ));

   265 

   266         switch( iIniPhase )

   267             {

   268             case EPBInitPhaseADN:

   269                 {

   270                 // Create Data for ADN EF read

   271                 if( !iExtensionPresent )

   272                     {

   273                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - ADN Init for Fileinfo OR FileData");

   274                     OstTrace0( TRACE_FATAL, DUP1_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq - ADN Init for Fileinfo OR FileData" );

   275                     // Send Request to read File Info or data from EFadn (depends upon iServiceType)

   276                     cmdParams.fileId = PB_ADN_FID;

   277                     cmdParams.serviceType = iServiceType;

   278                     cmdParams.record = 0;

   279                     }

   280                 else

   281                     {

   282                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - ADN Phonebook Init Extension request");

   283                     OstTrace0( TRACE_FATAL, DUP2_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq - ADN Phonebook Init Extension request" );

   284 

   285                     // Initialization for EXT1

   286                     cmdParams.fileId = PB_EXT1_FID;

   287                     cmdParams.serviceType = iServiceType;

   288                     cmdParams.record = 0;

   289                     }

   290                 break;

   291                 }

   292             case EPBInitPhaseFDN:

   293                 {

   294                 // Create Data for FDN EF read

   295                 if( !iExtensionPresent )

   296                     {

   297                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - FDN Init FileInfo OR FileData request");

   298                     OstTrace0( TRACE_FATAL, DUP3_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq -  FDN Init FileInfo OR FileData request" );

   299 

   300                     cmdParams.fileId = PB_FDN_FID;

   301                     cmdParams.serviceType = iServiceType;

   302                     cmdParams.record = 0;

   303                     }

   304                 else

   305                     {

   306                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - FDN Init Extension request");

   307                     OstTrace0( TRACE_FATAL, DUP4_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq - FDN Init Extension request" );

   308 

   309                     // Initialization for EXT2

   310                     cmdParams.fileId = PB_EXT2_FID;

   311                     cmdParams.serviceType = iServiceType;

   312                     cmdParams.record = 0;

   313                     }

   314                 break;

   315                 }

   316             case EPBInitPhaseSDN:

   317                 {

   318                 if( !iExtensionPresent )

   319                     {

   320                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - SDN Init FileInfo OR FileData request");

   321                     OstTrace0( TRACE_FATAL, DUP5_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq - SDN Init FileInfo OR FileData request" );

   322 

   323                     cmdParams.fileId = PB_SDN_FID;

   324                     cmdParams.serviceType = iServiceType;

   325                     cmdParams.record = 0;

   326                     }

   327                 else

   328                     {

   329                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - SDN Init Extension request");

   330                     OstTrace0( TRACE_FATAL, DUP6_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq - SDN Init Extension request" );

   331 

   332                     // Initialization for EXT3

   333                     cmdParams.fileId = PB_EXT3_FID;

   334                     cmdParams.serviceType = iServiceType;

   335                     cmdParams.record = 0;

   336                     }

   337                 break;

   338                 }

   339             case EPBInitPhaseMBDN:

   340                 {

   341                 if( !iExtensionPresent )

   342                     {

   343                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - MBDN Init FileInfo OR FileData request");

   344                     OstTrace0( TRACE_FATAL, DUP7_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq - MBDN Init FileInfo OR FileData request" );

   345 

   346                     cmdParams.fileId = PB_MBDN_FID;

   347                     cmdParams.serviceType = iServiceType;

   348                     cmdParams.record = 0;

   349                     }

   350                 else

   351                     {

   352                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - MBDN Init Extension request");

   353                     OstTrace0( TRACE_FATAL, DUP8_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq - MBDN Init Extension request" );

   354 

   355                     cmdParams.fileId = PB_EXT6_FID;

   356                     cmdParams.serviceType = iServiceType;

   357                     cmdParams.record = 0;

   358                     }

   359                 break;

   360                 }

   361             case EPBInitPhaseMSISDN:

   362                 {

   363                 if( !iExtensionPresent )

   364                     {

   365                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - MSISDN Init FileInfo OR FileData request");

   366                     OstTrace0( TRACE_FATAL, DUP9_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq - MSISDN Init FileInfo OR FileData request" );

   367 

   368                     cmdParams.fileId = PB_MSISDN_FID;

   369                     cmdParams.serviceType = iServiceType;

   370                     cmdParams.record = 0;

   371                     }

   372                 else

   373                     {

   374                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - MSISDN Init Extension request");

   375                     OstTrace0( TRACE_NORMAL, DUP10_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq" );

   376 

   377                     cmdParams.fileId = PB_EXT5_FID;

   378                     cmdParams.serviceType = iServiceType;

   379                     cmdParams.record = 0;

   380                     }

   381                 break;

   382                 }

   383             case EPBInitPhaseVMBX:

   384                 {

   385                 if( !iExtensionPresent )

   386                     {

   387                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - VMBX Init FileInfo OR FileData request");

   388                     OstTrace0( TRACE_FATAL, DUP11_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq - VMBX Init FileInfo OR FileData request" );

   389 

   390                     cmdParams.fileId = PB_VMBX_FID;

   391                     cmdParams.serviceType = iServiceType;

   392                     cmdParams.record = 0;

   393                     }

   394                 else

   395                     {

   396                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - VMBX Init Extension request");

   397                     OstTrace0( TRACE_NORMAL, DUP13_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq - VMBX Init Extension request" );

   398 

   399                     cmdParams.fileId = PB_EXT1_FID;

   400                     cmdParams.serviceType = iServiceType;

   401                     cmdParams.record = 0;

   402                     }

   403                 break;

   404                 }

   405             default:

   406                 {

   407                 TFLOGSTRING("TSY: CMmPhoneBookOperationInit::UICCInitializeReq - PhoneBook not supported ");

   408                 OstTrace0( TRACE_NORMAL, DUP12_CMMPHONEBOOKOPERATIONINIT_UICCINITIALIZEREQ, "CMmPhoneBookOperationInit::UICCInitializeReq - PhoneBook not supported" );

   409                 break;

   410                 }

   411             }

   412 

   413     // if intialization has not been completed till now then send the

   414     // request for the correct phase

   415 

   416     if( EPBIniPhase_PBInitialized != iIniPhase )

   417         {

   418         ret = iMmPhoneBookStoreMessHandler->UiccMessHandler()->CreateUiccApplCmdReq( cmdParams );

   419         TFLOGSTRING2("TSY: CreateUiccApplCmdReq returns %d", ret);

   420         }

   421     return ret;

   422     }

   423 

   424 

   425 

   426 

   427 

   428 /// RECEPTION

   429 

   430 

   431 

   432 // -----------------------------------------------------------------------------

   433 // CMmPhoneBookOperationInit::HandleUICCPbResp

   434 // Handle Response for SIM

   435 // -----------------------------------------------------------------------------

   436 //

   437 TInt CMmPhoneBookOperationInit::HandleUICCPbRespL

   438     (

   439     TBool &aComplete,

   440     TInt aStatus,

   441     const TDesC8 &aFileData,

   442     TInt /*aTransId*/

   443     )

   444     {

   445     TInt ret( KErrNone );

   446     // break immediatelly in case of internal init

   447     if ( iInternalInit )

   448         {

   449         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleUICCPbRespL. Internal Init->Break");

   450 OstTrace0( TRACE_NORMAL, DUP2_CMMPHONEBOOKOPERATIONINIT_HANDLEUICCPBRESPL, "CMmPhoneBookOperationInit::HandleUICCPbRespL, Internal Init->Break" );

   451 

   452         iIniPhase = EPBIniPhase_Unknown;

   453 

   454         // set flag to indicate that we can remove this operation from array

   455         aComplete = ETrue;

   456         iInternalInit = EFalse;

   457         return KErrNone;

   458         }

   459 

   460     // Handle recponse from UICC server

   461         ret = HandlePBRespL(aFileData,aStatus);

   462 

   463 

   464          // Complete, if phonebook initalization is complete or there is some error in UICC server

   465          if (KErrNone != ret || EPBIniPhase_PBInitialized == iIniPhase )

   466              {

   467              CPhoneBookDataPackage phoneBookData;

   468              phoneBookData.SetPhoneBookName( iPhonebookType );

   469              phoneBookData.PackData( iPBStoreInfoData );

   470 

   471              if ( KErrNone != ret )

   472                  {

   473                  ret = CMmStaticUtility::UICCCSCauseToEpocError( ret );

   474                  }

   475 

   476              iMmPhoneBookStoreMessHandler->MessageRouter()->Complete(

   477                      EMmTsyPhoneBookStoreInitIPC,

   478                      &phoneBookData,

   479                      ret );

   480              aComplete = ETrue;

   481              }

   482     return ret;

   483     }

   484 

   485 

   486 

   487 

   488 // -----------------------------------------------------------------------------

   489 // CMmPhoneBookOperationInit::HandlePBRespL

   490 // Further Handle Response for SIM

   491 // -----------------------------------------------------------------------------

   492 //

   493 TInt CMmPhoneBookOperationInit::HandlePBRespL(const TDesC8& aFileData, TInt aStatus )

   494     {

   495     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandlePBRespL");

   496     OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONINIT_HANDLEPBRESPL, "CMmPhoneBookOperationInit::HandlePBRespL" );

   497 

   498     TInt ret(KErrNone);

   499 

   500     if(!iExtensionPresent)

   501         {

   502         ret = HandleFileResp(aFileData, aStatus);

   503         }

   504     else

   505         {

   506         // For Extension File

   507         ret = HandleEXTFileResp(aFileData, aStatus);

   508         }

   509 

   510     if(KErrNone == ret)

   511         {

   512         ret = UICCInitializeReq();

   513         }

   514 

   515     return ret;

   516     }

   517 

   518 

   519 

   520 // -----------------------------------------------------------------------------

   521 // CMmPhoneBookOperationInit::HandleFileResp

   522 // Further Handle Response for phonebook EF Files

   523 // -----------------------------------------------------------------------------

   524 //

   525 TInt CMmPhoneBookOperationInit::HandleFileResp(const TDesC8 &aFileData, TInt aStatus)

   526     {

   527     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp");

   528     OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp" );

   529 

   530 

   531     TInt ret(KErrNone);

   532     TInt numOfEntries(0);

   533     TInt textLength(0);

   534     TInt numLength(0);

   535     TInt recordLength(0);

   536 

   537     if(UICC_STATUS_OK == aStatus)

   538         {

   539         if(UICC_APPL_FILE_INFO == iServiceType)

   540             {

   541             // get the ecord length

   542             HandleFcpData(aFileData,recordLength,KRecordLength);

   543 

   544             // Get the no of entries

   545             HandleFcpData(aFileData,numOfEntries,KNoOfRecords);

   546 

   547             // get Text length

   548             textLength = (recordLength - 14);

   549 

   550             // To get the total length of number, need to read Ext2 file

   551             // IF EXT2 is not present then only 20 BCD digits can be stored

   552             numLength =  UICC_NO_EXT_MAX_NUM_LEN;

   553             }

   554         else if(UICC_APPL_READ_LINEAR_FIXED == iServiceType)

   555             {

   556             TUint8 infoEXT ( aFileData[(textLength + 14)] );

   557             if( 0xFF != infoEXT)

   558                 {

   559                 // Send Request to read File info from EXT file

   560                 iExtensionPresent = ETrue;

   561                 }

   562             }

   563         }

   564 

   565         switch(iIniPhase)

   566             {

   567             case EPBInitPhaseADN:

   568                 {

   569                 if( UICC_STATUS_OK == aStatus )

   570                     {

   571                     if(UICC_APPL_FILE_INFO == iServiceType)

   572                         {

   573                         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for ADN Phonebook");

   574                         OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for ADN Phonebook" );

   575                         // Check for ADN phone book is incalidated by Fdn phonebook or not

   576                         TInt status(0);

   577                         HandleFcpData(aFileData,status,KFileStatus);

   578 

   579                         // check for ADN is invalidated or not

   580                         if(!(status & 0x01))

   581                             {

   582                             // Check for ADN is updatable or not when ADN is invalidated

   583                             if( 0x04 == (status & 0x04))

   584                                 {

   585                                 iPBStoreInfoData->iADNNumOfEntries = numOfEntries;

   586                                 iPBStoreInfoData->iADNNumberLengthMax = numLength;

   587                                 iPBStoreInfoData->iADNTextLengthMax = textLength;

   588                                 // Change ServiceType to read File Data to get final number length

   589                                 iServiceType = UICC_APPL_READ_LINEAR_FIXED;

   590                                 }

   591                             else   // when ADN is not updatable

   592                                 {

   593                                 iServiceType = UICC_APPL_FILE_INFO;

   594                                 iIniPhase = EPBInitPhaseFDN;

   595                                 }

   596                             }

   597                         else   // When ADN Phoenbook is not invalidated

   598                             {

   599                             iPBStoreInfoData->iADNNumOfEntries = numOfEntries;

   600                             iPBStoreInfoData->iADNNumberLengthMax = numLength;

   601                             iPBStoreInfoData->iADNTextLengthMax = textLength;

   602                             // Change ServiceType to read File Data to get final number length

   603                             iServiceType = UICC_APPL_READ_LINEAR_FIXED;

   604                             }

   605                         }

   606                     else if(UICC_APPL_READ_LINEAR_FIXED == iServiceType)

   607                         {

   608                         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for ADN Phonebook");

   609                         OstTrace0( TRACE_NORMAL, DUP2_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for ADN Phonebook" );

   610 

   611                         iServiceType = UICC_APPL_FILE_INFO;

   612 

   613                         if( !iMmUiccMessHandler->GetServiceStatus( ICC_EXT1_SERVICE_NUM) || (!iExtensionPresent) )

   614                             {

   615                             iExtensionPresent = EFalse;

   616                             iIniPhase = GetNextAvailablePbIcc(ICC_ADN_SERVICE_NUM);

   617                             }

   618                         // ADN Phonebook is initilized

   619                         iADNPbInitilized = ETrue;

   620                         }

   621                     }

   622                 else

   623                     {

   624                     // reset all the data is init is incomplete

   625                     iPBStoreInfoData->iADNNumOfEntries = -1;

   626                     iPBStoreInfoData->iADNNumberLengthMax = -1;

   627                     iPBStoreInfoData->iADNTextLengthMax = -1;

   628 

   629                     // Set ADn intialized flag to False

   630 

   631                     iADNPbInitilized = EFalse;

   632                     }

   633                 }

   634                 break;

   635             case EPBInitPhaseFDN:

   636                 {

   637                 if( UICC_STATUS_OK == aStatus )

   638                     {

   639                     if(UICC_APPL_FILE_INFO == iServiceType)

   640                         {

   641                         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for FDN Phonebook");

   642                         OstTrace0( TRACE_NORMAL, DUP3_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for FDN Phonebook" );

   643 

   644                         iPBStoreInfoData->iFDNNumOfEntries = numOfEntries;

   645                         iPBStoreInfoData->iFDNNumberLengthMax = numLength;

   646                         iPBStoreInfoData->iFDNTextLengthMax = textLength;

   647                         // Change ServiceType to read File Data to get final number length

   648                         iServiceType = UICC_APPL_READ_LINEAR_FIXED;

   649                         }

   650                     else if(UICC_APPL_READ_LINEAR_FIXED == iServiceType)

   651                         {

   652                         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for FDN Phonebook");

   653                         OstTrace0( TRACE_NORMAL, DUP4_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for ADN Phonebook" );

   654 

   655                         if(UICC_CARD_TYPE_ICC == iMmUiccMessHandler->GetCardType())

   656                             {

   657                             // Check for Exension

   658                             // Check for EXT1 Service is present or not

   659                             if( !iMmUiccMessHandler->GetServiceStatus( ICC_EXT2_SERVICE_NUM) || (!iExtensionPresent))

   660                                 {

   661                                 iExtensionPresent = EFalse;

   662                                 iIniPhase = GetNextAvailablePbIcc(ICC_FDN_SERVICE_NUM);

   663                                 }

   664                             }

   665                         else if(UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType())

   666                             {

   667                             // Chekc for Extension

   668                             // Check for EXT1 Service is present or not

   669                             if( !iMmUiccMessHandler->GetServiceStatus( UICC_EXT2_SERVICE_NUM) || (!iExtensionPresent))

   670                                 {

   671                                 iExtensionPresent = EFalse;

   672                                 iIniPhase = GetNextAvailablePbUicc(UICC_FDN_SERVICE_NUM);

   673                                 }

   674                             }

   675                         iServiceType = UICC_APPL_FILE_INFO;

   676                         }

   677                     }

   678                 else

   679                     {

   680                     // Reset all the Data if initilized incomplete

   681                     iPBStoreInfoData->iFDNNumOfEntries = -1;

   682                     iPBStoreInfoData->iFDNNumberLengthMax = -1;

   683                     iPBStoreInfoData->iFDNTextLengthMax = -1;

   684 

   685                     // Check for ADN Phonebook is Initilized or not

   686                     if(EFalse == iADNPbInitilized)

   687                         {

   688                         ret = KErrGeneral;

   689                         }

   690                     }

   691                 }

   692                 break;

   693             case EPBInitPhaseSDN:

   694                 {

   695                 if( UICC_STATUS_OK == aStatus )

   696                     {

   697                     if(UICC_APPL_FILE_INFO == iServiceType)

   698                         {

   699                         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for SDN Phonebook");

   700                         OstTrace0( TRACE_NORMAL, DUP5_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for SDN Phonebook" );

   701 

   702                         iPBStoreInfoData->iSDNNumOfEntries = numOfEntries;

   703                         iPBStoreInfoData->iSDNNumberLengthMax = numLength;

   704                         iPBStoreInfoData->iSDNTextLengthMax = textLength;

   705                         // Change ServiceType to read File Data to get final number length

   706                         iServiceType = UICC_APPL_READ_LINEAR_FIXED;

   707                         }

   708                     else if(UICC_APPL_READ_LINEAR_FIXED == iServiceType)

   709                         {

   710                         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for SDN Phonebook");

   711                         OstTrace0( TRACE_NORMAL, DUP6_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for ADN Phonebook" );

   712 

   713                         if(UICC_CARD_TYPE_ICC == iMmUiccMessHandler->GetCardType())

   714                             {

   715                             // Check for Exension

   716                             // Check for EXT1 Service is present or not

   717                             if( !iMmUiccMessHandler->GetServiceStatus( ICC_EXT3_SERVICE_NUM) || (!iExtensionPresent))

   718                                 {

   719                                 iExtensionPresent = EFalse;

   720                                 iIniPhase = GetNextAvailablePbIcc(ICC_SDN_SERVICE_NUM);

   721                                 }

   722                             }

   723                         else if(UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType())

   724                             {

   725                             // Chekc for Extension

   726                             // Check for EXT1 Service is present or not

   727                             if( !iMmUiccMessHandler->GetServiceStatus( UICC_EXT3_SERVICE_NUM ) || (!iExtensionPresent))

   728                                 {

   729                                 iExtensionPresent = EFalse;

   730                                 iIniPhase = GetNextAvailablePbUicc(UICC_SDN_SERVICE_NUM);

   731                                 }

   732                             }

   733                         iServiceType = UICC_APPL_FILE_INFO;

   734                         }

   735                     }

   736                 else

   737                     {

   738                     // Reset all the parameters if init incomplete

   739                     iPBStoreInfoData->iSDNNumOfEntries = -1;

   740                     iPBStoreInfoData->iSDNNumberLengthMax = -1;

   741                     iPBStoreInfoData->iSDNTextLengthMax = -1;

   742                     }

   743                 }

   744                 break;

   745             case EPBInitPhaseMBDN:

   746                 {

   747                 if( UICC_STATUS_OK == aStatus )

   748                     {

   749                     if(UICC_APPL_FILE_INFO == iServiceType)

   750                         {

   751                         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for MBDN Phonebook");

   752                         OstTrace0( TRACE_NORMAL, DUP7_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for MBDN Phonebook" );

   753 

   754                         iPBStoreInfoData->iMBDNNumOfEntries = numOfEntries;

   755                         iPBStoreInfoData->iMBDNNumberLengthMax = numLength;

   756                         iPBStoreInfoData->iMBDNTextLengthMax = textLength;

   757                         // Change ServiceType to read File Data to get final number length

   758                         iServiceType = UICC_APPL_READ_LINEAR_FIXED;

   759                         }

   760                     else if( UICC_APPL_READ_LINEAR_FIXED == iServiceType)

   761                         {

   762                         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for MBDN Phonebook");

   763                         OstTrace0( TRACE_NORMAL, DUP8_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for MBDN Phonebook" );

   764 

   765                         if(!iExtensionPresent)

   766                             {

   767                             if(UICC_CARD_TYPE_ICC == iMmUiccMessHandler->GetCardType())

   768                                 iIniPhase = GetNextAvailablePbIcc(ICC_MBDN_SERVICE_NUM);

   769                             else if(UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType())

   770                                 iIniPhase = GetNextAvailablePbUicc(UICC_MBDN_SERVICE_NUM);

   771                             }

   772                         iServiceType = UICC_APPL_FILE_INFO;

   773                         }

   774                     }

   775                 else

   776                     {

   777                     // reset all the paramenters if init ic incomplete

   778                     iPBStoreInfoData->iMBDNNumOfEntries = -1;

   779                     iPBStoreInfoData->iMBDNNumberLengthMax = -1;

   780                     iPBStoreInfoData->iMBDNTextLengthMax = -1;

   781                     }

   782                 }

   783                 break;

   784             case EPBInitPhaseMSISDN:

   785                 {

   786                 if( UICC_STATUS_OK == aStatus )

   787                     {

   788                     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for MSISDN Phonebook");

   789                     OstTrace0( TRACE_NORMAL, DUP9_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for MSISDN Phonebook" );

   790 

   791                     if(UICC_APPL_FILE_INFO == iServiceType)

   792                         {

   793                         iPBStoreInfoData->iMSISDNNumOfEntries = numOfEntries;

   794                         iPBStoreInfoData->iMSISDNNumberLengthMax = numLength;

   795                         iPBStoreInfoData->iMSISDNTextLengthMax = textLength;

   796                         // Change ServiceType to read File Data to get final number length

   797                         iServiceType = UICC_APPL_READ_LINEAR_FIXED;

   798                         }

   799                     else if(UICC_APPL_READ_LINEAR_FIXED == iServiceType)

   800                         {

   801                         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for MSISDN Phonebook");

   802                         OstTrace0( TRACE_NORMAL, DUP10_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for MSISDN Phonebook" );

   803 

   804                         if(UICC_CARD_TYPE_ICC == iMmUiccMessHandler->GetCardType())

   805                             {

   806                             // Check for Exension

   807                             // Check for EXT1 Service is present or not

   808                             if( !iMmUiccMessHandler->GetServiceStatus( ICC_EXT1_SERVICE_NUM ) || (!iExtensionPresent))

   809                                 {

   810                                 iExtensionPresent= EFalse;

   811                                 iIniPhase = GetNextAvailablePbIcc(ICC_MSISDN_SERVICE_NUM);

   812                                 }

   813                             }

   814                         else if(UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType())

   815                             {

   816                             // Chekc for Extension

   817                             // Check for EXT1 Service is present or not

   818                             if( !iMmUiccMessHandler->GetServiceStatus( UICC_EXT5_SERVICE_NUM ) || (!iExtensionPresent))

   819                                 {

   820                                 iExtensionPresent = EFalse;

   821                                 iIniPhase = GetNextAvailablePbUicc(UICC_MSISDN_SERVICE_NUM);

   822                                 }

   823                             }

   824                         iServiceType = UICC_APPL_FILE_INFO;

   825                         }

   826                     }

   827                 else

   828                     {

   829                     // reste all the parameters if init is incomplete

   830                     iPBStoreInfoData->iMSISDNNumOfEntries = -1;

   831                     iPBStoreInfoData->iMSISDNNumberLengthMax = -1;

   832                     iPBStoreInfoData->iMSISDNTextLengthMax = -1;

   833                     }

   834                 }

   835                 break;

   836             case EPBInitPhaseVMBX:

   837                 {

   838                 if( UICC_STATUS_OK == aStatus )

   839                     {

   840                     if(UICC_APPL_FILE_INFO == iServiceType)

   841                         {

   842                         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for VMBX Phonebook");

   843                         OstTrace0( TRACE_NORMAL, DUP13_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Info for VMBX Phonebook" );

   844 

   845                         iPBStoreInfoData->iVMBXNumOfEntries = numOfEntries;

   846                         iPBStoreInfoData->iVMBXNumberLengthMax = numLength;

   847                         iPBStoreInfoData->iVMBXTextLengthMax = textLength;

   848                         // Change ServiceType to read File Data to get final number length

   849                         iServiceType = UICC_APPL_READ_LINEAR_FIXED;

   850                         }

   851                     else if(UICC_APPL_READ_LINEAR_FIXED == iServiceType)

   852                         {

   853                         TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for VMBX Phonebook");

   854                         OstTrace0( TRACE_NORMAL, DUP11_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - Handle File Data for VMBX Phonebook" );

   855 

   856                             // Check for Exension

   857                             // Check for EXT1 Service is present or not

   858                             if( !iMmUiccMessHandler->GetServiceStatus( ICC_EXT1_SERVICE_NUM) || ( !iExtensionPresent ))

   859                                 {

   860                                 iExtensionPresent = EFalse;

   861                                 iIniPhase = EPBIniPhase_PBInitialized;

   862                                 }

   863                         iServiceType = UICC_APPL_FILE_INFO;

   864                         }

   865                     }

   866                 else

   867                     {

   868                     // Reset all the parameters if init incomplete

   869                     iPBStoreInfoData->iVMBXNumOfEntries = -1;

   870                     iPBStoreInfoData->iVMBXNumberLengthMax = -1;

   871                     iPBStoreInfoData->iVMBXTextLengthMax = -1;

   872                     }

   873                 }

   874                 break;

   875             default:

   876                 {

   877                 TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleFileResp - PhoneBook not supported");

   878                 OstTrace0( TRACE_NORMAL, DUP12_CMMPHONEBOOKOPERATIONINIT_HANDLEFILERESP, "CMmPhoneBookOperationInit::HandleFileResp - PhoneBook not supported" );

   879                 }

   880                 break;

   881             }

   882 

   883     if( ( UICC_STATUS_OK != aStatus ) && ( KErrNone == ret ) )

   884         {

   885         iServiceType = UICC_APPL_FILE_INFO;

   886         GetNextPhoneBookInitPhase(iIniPhase);

   887         }

   888     return ret;

   889 

   890     }

   891 

   892 

   893 

   894 // -----------------------------------------------------------------------------

   895 // CmmPhonebookOperationInit::HandleEXTFileResp

   896 // Further handles response for Phonebook EXT Files

   897 // -----------------------------------------------------------------------------

   898 //

   899 

   900 

   901 TInt CMmPhoneBookOperationInit::HandleEXTFileResp( const TDesC8 &aFileData , TInt aStatus)

   902     {

   903     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleEXTFileResp");

   904     OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONINIT_HANDLEEXTFILERESP, "CMmPhoneBookOperationInit::HandleEXTFileResp" );

   905 

   906 

   907     TInt ret(KErrNone);

   908     if(UICC_STATUS_OK == aStatus)

   909         {

   910         // no of records in EXT2 EF

   911         TInt noOfRecords(0);

   912         // get the no of records

   913         HandleFcpData(aFileData,noOfRecords,KNoOfRecords);

   914 

   915         // To get the total length of number

   916         // Where multiply by 11 is the no of bytes in extension data and multiply by 2 is for BCD coding while

   917         //storing data in EXT2 file

   918         TInt numLength =  UICC_NO_EXT_MAX_NUM_LEN + (11*noOfRecords*2);

   919 

   920         // Change Extension present to read PhoneBook EF file info

   921         iExtensionPresent = EFalse;

   922         iServiceType = UICC_APPL_FILE_INFO;

   923 

   924         switch(iIniPhase)

   925             {

   926             case EPBInitPhaseADN:

   927                 {

   928                 TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleEXTFileResp - For ADN Phone book");

   929                 OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONINIT_HANDLEEXTFILERESP, "CMmPhoneBookOperationInit::HandleEXTFileResp - For ADN Phone book" );

   930 

   931                 iPBStoreInfoData->iADNNumberLengthMax = numLength;

   932                 // Change the Initialization Phase to next

   933                 // Get next available phonebook in UST table

   934                 iIniPhase =  GetNextAvailablePbIcc(UICC_FDN_SERVICE_NUM);

   935                 }

   936                 break;

   937             case EPBInitPhaseFDN:

   938                 {

   939                 TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleEXTFileResp - For FDN PhoneBook");

   940                 OstTrace0( TRACE_NORMAL, DUP2_CMMPHONEBOOKOPERATIONINIT_HANDLEEXTFILERESP, "CMmPhoneBookOperationInit::HandleEXTFileResp  -For FDN PhoneBoo" );

   941 

   942                 iPBStoreInfoData->iFDNNumberLengthMax = numLength;

   943 

   944                 if(UICC_CARD_TYPE_ICC == iMmUiccMessHandler->GetCardType())

   945                     {

   946                     iIniPhase = GetNextAvailablePbIcc(ICC_FDN_SERVICE_NUM);

   947                     }

   948                 else if(UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType())

   949                     {

   950                     iIniPhase = GetNextAvailablePbUicc(UICC_FDN_SERVICE_NUM);

   951                     }

   952                 }

   953                 break;

   954             case EPBInitPhaseSDN:

   955                 {

   956                 TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleEXTFileResp - For SDN PhoneBook");

   957                 OstTrace0( TRACE_NORMAL, DUP3_CMMPHONEBOOKOPERATIONINIT_HANDLEEXTFILERESP, "CMmPhoneBookOperationInit::HandleEXTFileResp - For SDN PhoneBook" );

   958 

   959                 iPBStoreInfoData->iSDNNumberLengthMax = numLength;

   960 

   961                 if(UICC_CARD_TYPE_ICC == iMmUiccMessHandler->GetCardType())

   962                     {

   963                     iIniPhase = GetNextAvailablePbIcc(ICC_SDN_SERVICE_NUM);

   964                     }

   965                 else if(UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType())

   966                 {

   967                 iIniPhase = GetNextAvailablePbUicc(UICC_SDN_SERVICE_NUM);

   968                 }

   969 

   970                 }

   971                 break;

   972             case EPBInitPhaseMBDN:

   973                 {

   974                 TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleEXTFileResp - for MBDN PhoneBook");

   975                 OstTrace0( TRACE_NORMAL, DUP4_CMMPHONEBOOKOPERATIONINIT_HANDLEEXTFILERESP, "CMmPhoneBookOperationInit::HandleEXTFileResp - for MBDN PhoneBook" );

   976 

   977                 iPBStoreInfoData->iMBDNNumberLengthMax = numLength;

   978 

   979                 if(UICC_CARD_TYPE_ICC == iMmUiccMessHandler->GetCardType())

   980                     {

   981                     iIniPhase = GetNextAvailablePbIcc(ICC_MBDN_SERVICE_NUM);

   982                     }

   983                 else if(UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType())

   984                     {

   985                     iIniPhase = GetNextAvailablePbUicc(UICC_MBDN_SERVICE_NUM);

   986                     }

   987                 }

   988                 break;

   989             case EPBInitPhaseMSISDN:

   990                 {

   991                 TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleEXTFileResp - for MSISDN Phonebook");

   992                 OstTrace0( TRACE_NORMAL, DUP5_CMMPHONEBOOKOPERATIONINIT_HANDLEEXTFILERESP, "CMmPhoneBookOperationInit::HandleEXTFileResp - for MSISDN Phonebook" );

   993 

   994                 iPBStoreInfoData->iMSISDNNumberLengthMax = numLength;

   995 

   996                 if(UICC_CARD_TYPE_ICC == iMmUiccMessHandler->GetCardType())

   997                     {

   998                     iIniPhase = GetNextAvailablePbIcc(ICC_MSISDN_SERVICE_NUM);

   999                     }

  1000                 else if(UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType())

  1001                     {

  1002                     iIniPhase = GetNextAvailablePbUicc(UICC_MSISDN_SERVICE_NUM);

  1003                     }

  1004                 }

  1005                 break;

  1006             case EPBInitPhaseVMBX:

  1007                 {

  1008                 TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleEXTFileResp  - For VMBX PhoneBook");

  1009                 OstTrace0( TRACE_NORMAL, DUP6_CMMPHONEBOOKOPERATIONINIT_HANDLEEXTFILERESP, "CMmPhoneBookOperationInit::HandleEXTFileResp - For VMBX PhoneBook" );

  1010 

  1011                 iPBStoreInfoData->iVMBXNumberLengthMax = numLength;

  1012                 iIniPhase = EPBIniPhase_PBInitialized;

  1013                 }

  1014                 break;

  1015             default:

  1016                 {

  1017                 TFLOGSTRING("TSY: CMmPhoneBookOperationInit::HandleEXTFileResp  - PhoneBook not supported");

  1018                 OstTrace0( TRACE_NORMAL, DUP7_CMMPHONEBOOKOPERATIONINIT_HANDLEEXTFILERESP, "CMmPhoneBookOperationInit::HandleEXTFileResp - PhoneBook not supported" );

  1019                 }

  1020                 break;

  1021             }

  1022 

  1023         }

  1024     else

  1025         {

  1026         iServiceType = UICC_APPL_FILE_INFO;

  1027         GetNextPhoneBookInitPhase(iIniPhase);

  1028         }

  1029     return ret;

  1030     }

  1031 

  1032 

  1033 

  1034 

  1035 

  1036 // -----------------------------------------------------------------------------

  1037 // CMmPhoneBookOperationInit::GetNextAvailablePbUicc

  1038 // Gets next phonebook to be initialized in SST Servicetable

  1039 // by index

  1040 // -----------------------------------------------------------------------------

  1041 //

  1042 

  1043 TUint8 CMmPhoneBookOperationInit::GetNextAvailablePbIcc(TUint8 aPBook)

  1044     {

  1045     TFLOGSTRING("TSY: CMmPhoneBookOperationInit::GetNextAvailablePbIcc");

  1046     OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONINIT_GETNEXTAVAILABLEPBICC, "CMmPhoneBookOperationInit::GetNextAvailablePbIcc" );

  1047 

  1048     switch(aPBook)

  1049         {

  1050         case ICC_ADN_SERVICE_NUM:

  1051             {

  1052             if(iMmUiccMessHandler->GetServiceStatus( ICC_FDN_SERVICE_NUM))

  1053                 {

  1054                 aPBook = EPBInitPhaseFDN;

  1055                 }

  1056             else if(iMmUiccMessHandler->GetServiceStatus( ICC_SDN_SERVICE_NUM))

  1057                 {

  1058                 aPBook = EPBInitPhaseSDN;

  1059                 }

  1060             else if(iMmUiccMessHandler->GetServiceStatus( ICC_MBDN_SERVICE_NUM))

  1061                 {

  1062                 aPBook = EPBInitPhaseMBDN;

  1063                 }

  1064             else if(iMmUiccMessHandler->GetServiceStatus( ICC_MSISDN_SERVICE_NUM))

  1065                 {

  1066                 aPBook = EPBInitPhaseMSISDN;

  1067                 }

  1068             else if( iMmUiccMessHandler->GetCphsInformationStatus(ICC_MAILBOX_NUM)) // Service no need to be changed

  1069                 {

  1070                 aPBook = EPBInitPhaseVMBX;

  1071                 }

  1072             else

  1073                 {

  1074                 aPBook = EPBIniPhase_PBInitialized;

  1075                 }

  1076                // aPBook = EPBInitPhaseVMBX;

  1077             }

  1078             break;

  1079         case ICC_FDN_SERVICE_NUM:

  1080             {

  1081             if(iMmUiccMessHandler->GetServiceStatus( ICC_SDN_SERVICE_NUM))

  1082                 {

  1083                 aPBook = EPBInitPhaseSDN;

  1084                 }

  1085             else if(iMmUiccMessHandler->GetServiceStatus( ICC_MBDN_SERVICE_NUM))

  1086                 {

  1087                 aPBook = EPBInitPhaseMBDN;

  1088                 }

  1089             else if(iMmUiccMessHandler->GetServiceStatus( ICC_MSISDN_SERVICE_NUM))

  1090                 {

  1091                 aPBook = EPBInitPhaseMSISDN;

  1092                 }

  1093             else if(iMmUiccMessHandler->GetCphsInformationStatus( ICC_MAILBOX_NUM ))  // Service no need to changed

  1094                 {

  1095                 aPBook = EPBInitPhaseVMBX;

  1096                 }

  1097             else

  1098                 {

  1099                 aPBook = EPBIniPhase_PBInitialized;

  1100                // aPBook = EPBInitPhaseVMBX;

  1101                 }

  1102             }

  1103             break;

  1104         case ICC_SDN_SERVICE_NUM:

  1105             {

  1106             if(iMmUiccMessHandler->GetServiceStatus(ICC_MBDN_SERVICE_NUM))

  1107                 {

  1108                 aPBook = EPBInitPhaseMBDN;

  1109                 }

  1110             else if(iMmUiccMessHandler->GetServiceStatus(ICC_MSISDN_SERVICE_NUM))

  1111                 {

  1112                 aPBook = EPBInitPhaseMSISDN;

  1113                 }

  1114             else if( iMmUiccMessHandler->GetCphsInformationStatus( ICC_MAILBOX_NUM ))

  1115                 {

  1116                 aPBook = EPBInitPhaseVMBX;

  1117                 }

  1118             else

  1119                 {

  1120                 aPBook = EPBIniPhase_PBInitialized;

  1121                 //aPBook = EPBInitPhaseVMBX;

  1122                 }

  1123             }

  1124             break;

  1125         case ICC_MBDN_SERVICE_NUM:

  1126             {

  1127             if(iMmUiccMessHandler->GetServiceStatus( ICC_MSISDN_SERVICE_NUM))

  1128                 {

  1129                 aPBook = EPBInitPhaseMSISDN;

  1130                 }

  1131             else if( iMmUiccMessHandler->GetCphsInformationStatus( ICC_MAILBOX_NUM ))

  1132                 {

  1133                 aPBook = EPBInitPhaseVMBX;

  1134                 }