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

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 

    18 //  INCLUDE FILES

    19 #include "cmmonstoretsy.h"

    20 #include "cmmtsyreqhandlestore.h"

    21 #include "CMmPrivateUtility.h"

    22 #include "MmTsy_numberOfSlots.h"

    23 #include "MmTsy_timeoutdefs.h"

    24 #include "cmmmessagemanagerbase.h"

    25 #include "cmmpblist.h"

    26 #include "cmmphonebookstoretsy.h"

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

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

    29 

    30 // ======== MEMBER FUNCTIONS ========

    31 

    32 CMmONStoreTsy::CMmONStoreTsy()

    33     {

    34     }

    35 

    36 void CMmONStoreTsy::ConstructL()

    37     {

    38 TFLOGSTRING("TSY: CMmONStoreTsy::ConstructL");

    39 

    40 #ifdef REQHANDLE_TIMER

    41     // Create req handle store

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

    43         EMmTsyNumOfONStoreRequests, iStorageReqHandles );

    44 #else // REQHANDLE_TIMER

    45     // Create req handle store

    46     iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

    47         EMmTsyNumOfONStoreRequests, iStorageReqHandles );

    48 #endif // REQHANDLE_TIMER

    49 

    50     //get mode of current extension.

    51     RMobilePhone::TMobilePhoneNetworkMode currentMode;

    52     iMmPhone->GetStaticExtensionMode( &currentMode );

    53 

    54     // Reset phonebooktype and servicetype

    55     ResetVariables();

    56 

    57     // Create GSM ONStore objects

    58     iMmONStoreGsmExt = static_cast<CMmONStoreExtInterface*>(

    59         CMmONStoreGsmExt::NewL( this ) );

    60     // Set mode GSM

    61     iMmONStoreExtInterface = iMmONStoreGsmExt;

    62 

    63 

    64     //if current mode is GSM

    65     if ( RMobilePhone::ENetworkModeGsm == currentMode )

    66         {

    67         // Set phonebook type and servicetype

    68         iPhoneBookType = KSimMsisdn;  // MSISDN

    69         }

    70 

    71     // Construct ReadAllList

    72     iONStoreListArray = new (ELeave) CArrayFixFlat<TONStoreMsg>(1);

    73 

    74     // Construct ReadAllArray

    75     iONStoreReadAllArray = new (ELeave) CArrayPtrFlat<CListReadAllAttempt>(1);

    76 

    77     //register ON Store tsy in the message manager

    78     iMmPhone->MessageManager()->RegisterTsyObject( 

    79         CMmMessageManagerBase::EONStoreTsy, this );

    80 

    81     // Reset info to fill with ini values

    82     SetInfo();

    83     }

    84 

    85 CMmONStoreTsy* CMmONStoreTsy::NewL(

    86     CMmPhoneTsy* aMmPhone )

    87     {

    88     CMmONStoreTsy* aMmONStoreTsy = new( ELeave ) CMmONStoreTsy();

    89     CleanupClosePushL( *aMmONStoreTsy );

    90 

    91     aMmONStoreTsy->iMmPhone = aMmPhone;

    92 

    93     aMmONStoreTsy->ConstructL();

    94     CleanupStack::Pop();

    95 

    96     return aMmONStoreTsy;

    97     }

    98 

    99 CMmONStoreTsy::~CMmONStoreTsy()

   100     {

   101 TFLOGSTRING("TSY: CMmONStoreTsy::~CMmONStoreTsy");

   102 

   103     if (iMmPhone )

   104         {

   105         // deregister tsy object from message manager

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

   107         }

   108 

   109     if ( NULL != iTsyReqHandleStore )

   110         {

   111         delete iTsyReqHandleStore;

   112         iTsyReqHandleStore = NULL;

   113         }

   114 

   115     // Delete ONStoreGsmExt

   116     delete iMmONStoreGsmExt;

   117     iMmONStoreGsmExt = NULL;

   118 

   119     // Delete TSY's internal ONStore list

   120     delete iONStoreListArray;

   121     iONStoreListArray = NULL;

   122 

   123     // Delete ONStoreReadAll array

   124     iONStoreReadAllArray->ResetAndDestroy();

   125     delete iONStoreReadAllArray;

   126     iONStoreReadAllArray = NULL;

   127     }

   128 

   129 // ---------------------------------------------------------------------------

   130 // CMmONStoreTsy::Init

   131 // Initialisation method that is called from ETel Server.

   132 // This is an initialization method for the class functionality.

   133 // Generally initization method inits e.g. class attributes.

   134 // In this case, this method is not needed.

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

   136 // ---------------------------------------------------------------------------

   137 //

   138 void CMmONStoreTsy::Init()

   139     {

   140     }

   141 

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

   143 // CMmONStoreTsy::OpenNewObjectByNameL

   144 // This method opens extendable sub-sessions

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

   146 // ---------------------------------------------------------------------------

   147 //

   148 CTelObject* CMmONStoreTsy::OpenNewObjectByNameL(

   149     const TDesC& )

   150     {

   151     User::Leave( KErrNotSupported );

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

   153     

   154     return NULL;

   155     }

   156 

   157 // ---------------------------------------------------------------------------

   158 // CMmONStoreTsy::OpenNewObjectL

   159 // This method opens extendable sub-sessions

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

   161 // ---------------------------------------------------------------------------

   162 //

   163 CTelObject* CMmONStoreTsy::OpenNewObjectL(

   164     TDes& )

   165     {

   166     User::Leave( KErrNotSupported );

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

   168     

   169     return NULL;

   170     }

   171 

   172 // ---------------------------------------------------------------------------

   173 // CMmONStoreTsy::ReqModeL

   174 // To ask what type of flow control is used for the IPC number.

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

   176 // ---------------------------------------------------------------------------

   177 //

   178 CTelObject::TReqMode CMmONStoreTsy::ReqModeL(

   179     const TInt aIpc )

   180     {

   181 TFLOGSTRING2("TSY: CMmONStoreTsy::ReqModeL IPC %d", aIpc);

   182     CTelObject::TReqMode ret=0;

   183     switch ( aIpc )

   184         {

   185         // Flow Controlled Services

   186         case EMobilePhoneStoreRead:

   187         case EMobilePhoneStoreWrite:

   188         case EMobilePhoneStoreDelete:

   189         case EMobilePhoneStoreDeleteAll:

   190         case EMobilePhoneStoreReadAllPhase1:

   191         case EMobilePhoneStoreReadAllPhase2:

   192         case EMobilePhoneStoreGetInfo:

   193         case EMobileONStoreStoreAll:

   194             ret=KReqModeFlowControlObeyed;

   195             break;

   196         // Multiple Completion Services with Immediate Server Repost

   197         // (Usually Notifications)

   198         case EMobilePhoneStoreNotifyStoreEvent:

   199             ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

   200             break;

   201         default:

   202             User::Leave(KErrNotSupported);

   203             break;

   204         }

   205         

   206     return ret;

   207     }

   208 

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

   210 // CMmONStoreTsy::RegisterNotification

   211 // Enables the TSY to "turn on" any regular notification

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

   213 // ---------------------------------------------------------------------------

   214 //

   215 TInt CMmONStoreTsy::RegisterNotification(

   216     const TInt aIpc )

   217     {

   218     TInt ret( KErrNone );

   219 

   220     switch ( aIpc )

   221         {

   222         case EMobilePhoneStoreNotifyStoreEvent:

   223             // KErrNone

   224             break;

   225         default:

   226             // Unknown or invalid IPC

   227             ret = KErrNotSupported;

   228         }

   229 

   230     return ret;

   231     }

   232 

   233 // ---------------------------------------------------------------------------

   234 // CMmONStoreTsy::DeregisterNotification

   235 // Enables the TSY to "turn off" any regular notification

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

   237 // ---------------------------------------------------------------------------

   238 //

   239 TInt CMmONStoreTsy::DeregisterNotification(

   240     const TInt aIpc )

   241     {

   242     TInt ret( KErrNone );

   243 

   244     switch ( aIpc )

   245         {

   246         case EMobilePhoneStoreNotifyStoreEvent:

   247             // KErrNone

   248             break;

   249         default:

   250             // Unknown or invalid IPC

   251             ret = KErrNotSupported;

   252         }

   253 

   254     return ret;

   255     }

   256 

   257 // ---------------------------------------------------------------------------

   258 // CMmONStoreTsy::NumberOfSlotsL

   259 // To ask the TSY how big buffer it wants

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

   261 // ---------------------------------------------------------------------------

   262 //

   263 TInt CMmONStoreTsy::NumberOfSlotsL(

   264     const TInt aIpc )

   265     {

   266     TInt numberOfSlots = 1;

   267 

   268     switch ( aIpc )

   269         {

   270         case EMobilePhoneStoreNotifyStoreEvent:

   271             numberOfSlots = KMmONStoreNotifyStoreEventSlots;

   272             break;

   273         default:

   274             // Unknown or invalid Phone IPC

   275             User::Leave( KErrNotSupported );

   276             break;

   277         }

   278 

   279     return numberOfSlots;

   280     }

   281 

   282 // ---------------------------------------------------------------------------

   283 // CMmONStoreTsy::ExtFunc

   284 // Handling of extended requests

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

   286 // ---------------------------------------------------------------------------

   287 //

   288 TInt CMmONStoreTsy::ExtFunc(

   289     const TTsyReqHandle aTsyReqHandle,

   290     const TInt aIpc,

   291     const TDataPackage& aPackage )

   292     {

   293 TFLOGSTRING3("TSY: CMmONStoreTsy::ExtFunc - IPC:%d Handle:%d", aIpc, aTsyReqHandle);   

   294                

   295     TInt ret = KErrNone;

   296     TInt trapError = KErrNone;

   297 

   298     // Reset last tsy request type

   299     iReqHandleType = EMultimodeONStoreReqHandleUnknown;

   300 

   301     TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ); );

   302 

   303     if ( KErrNone != trapError )

   304         {

   305         ReqCompleted( aTsyReqHandle, trapError );

   306         }

   307     else if ( KErrNone != ret )

   308         {

   309         ReqCompleted( aTsyReqHandle, ret );

   310         }

   311 

   312     // Save request handle

   313     if ( EMultimodeONStoreReqHandleUnknown != iReqHandleType )

   314         {

   315 #ifdef REQHANDLE_TIMER

   316         SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

   317 #else // REQHANDLE_TIMER

   318         iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, aTsyReqHandle );

   319 #endif // REQHANDLE_TIMER

   320         }

   321 

   322     return KErrNone;

   323     }

   324 

   325 // ---------------------------------------------------------------------------

   326 // CMmONStoreTsy::DoExtFuncL

   327 // Dispatches extension function requests

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

   329 // ---------------------------------------------------------------------------

   330 //

   331 TInt CMmONStoreTsy::DoExtFuncL(

   332     const TTsyReqHandle aTsyReqHandle,

   333     const TInt aIpc,

   334     const TDataPackage& aPackage )

   335     {

   336 TFLOGSTRING3("TSY: CMmONStoreTsy::DoExtFuncL - IPC:%d Handle:%d", aIpc, aTsyReqHandle);

   337 

   338     TAny* dataPtr=aPackage.Ptr1();

   339     TAny* dataPtr2=aPackage.Ptr2();

   340 

   341     // Create unique transaction id

   342 

   343     switch (aIpc)

   344         {

   345         case EMobilePhoneStoreRead:

   346             return ReadL( aPackage.Des1n() );

   347 

   348         case EMobilePhoneStoreWrite:

   349             return WriteL( aTsyReqHandle, aPackage.Des1n() );

   350 

   351         case EMobilePhoneStoreDelete:

   352             return DeleteL( aTsyReqHandle,

   353                 REINTERPRET_CAST( TInt*, dataPtr ) );

   354 

   355         case EMobilePhoneStoreDeleteAll:

   356             return DeleteAllL( aTsyReqHandle );

   357 

   358         case EMobilePhoneStoreGetInfo:

   359             return GetInfoL( aTsyReqHandle,

   360                 REINTERPRET_CAST( RMobileONStore::TMobileONStoreInfoV1*, 

   361                     dataPtr ) );

   362 

   363         case EMobilePhoneStoreReadAllPhase1:

   364             return ReadAllPhase1L( aTsyReqHandle,

   365                 REINTERPRET_CAST( RMobilePhone::TClientId*, dataPtr ),

   366                 REINTERPRET_CAST( TInt*, dataPtr2 ) );

   367 

   368         case EMobilePhoneStoreReadAllPhase2:

   369             return ReadAllPhase2( aTsyReqHandle,

   370                 REINTERPRET_CAST( RMobilePhone::TClientId*, dataPtr ), 

   371                 aPackage.Des2n() );

   372 

   373         case EMobilePhoneStoreNotifyStoreEvent:

   374             return NotifyStoreEvent(

   375                 REINTERPRET_CAST( RMobilePhoneStore::TMobileStoreEvent*, 

   376                 dataPtr ), REINTERPRET_CAST( TInt*, dataPtr2 ) );

   377 

   378         case EMobileONStoreStoreAll:

   379             return StoreAllL( aTsyReqHandle,aPackage.Des1n() );

   380 

   381         default:

   382             return KErrNotSupported;

   383         }

   384     }

   385 

   386 // ---------------------------------------------------------------------------

   387 // CMmONStoreTsy::CancelService

   388 // To cancel any extension requests

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

   390 // ---------------------------------------------------------------------------

   391 //

   392 TInt CMmONStoreTsy::CancelService(

   393     const TInt aIpc,

   394     const TTsyReqHandle aTsyReqHandle )

   395     {

   396     switch ( aIpc )

   397         {

   398         case EMobilePhoneStoreGetInfo:

   399             return GetInfoCancel( aTsyReqHandle );

   400         case EMobilePhoneStoreRead:

   401             return ReadCancel( aTsyReqHandle );

   402         case EMobilePhoneStoreWrite:

   403             return WriteCancel( aTsyReqHandle );

   404         case EMobilePhoneStoreDelete:

   405             // There is no change to cancel this request, so only thing to do,

   406             // is let the request continue and return KErrNone.

   407             return KErrNone;

   408         case EMobilePhoneStoreDeleteAll:

   409             return DeleteAllCancel( aTsyReqHandle );

   410         case EMobilePhoneStoreReadAllPhase1:

   411         case EMobilePhoneStoreReadAllPhase2:

   412             return ReadAllCancel( aTsyReqHandle );

   413         case EMobilePhoneStoreNotifyStoreEvent:

   414             return NotifyStoreEventCancel( aTsyReqHandle );

   415         case EMobileONStoreStoreAll:

   416             return StoreAllCancel( aTsyReqHandle );

   417         default:

   418             return KErrGeneral;

   419         }

   420     }

   421 

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

   423 // CMmONStoreTsy::SetActiveONStoreExtension

   424 // Sets pointer to active extension

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

   426 // ---------------------------------------------------------------------------

   427 //

   428 TInt CMmONStoreTsy::SetActiveONStoreExtension(

   429     CMmONStoreExtInterface* aMmONStoreExt )

   430     {

   431     TInt ret = KErrGeneral;

   432 

   433     if ( aMmONStoreExt )

   434         {

   435         iMmONStoreExtInterface = aMmONStoreExt;

   436         ret = KErrNone;

   437         }

   438 

   439     return ret;

   440     }

   441 

   442 // ---------------------------------------------------------------------------

   443 // CMmONStoreTsy::Returns a pointer to the active extension

   444 // Sets pointer to active extension

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

   446 // ---------------------------------------------------------------------------

   447 //

   448 CMmONStoreExtInterface* CMmONStoreTsy::ActiveONExtension()

   449     {

   450     return iMmONStoreExtInterface;

   451     }

   452 

   453 // ---------------------------------------------------------------------------

   454 // CMmONStoreTsy::ReadL

   455 // Read one ON store entry using index

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

   457 // ---------------------------------------------------------------------------

   458 //

   459 TInt CMmONStoreTsy::ReadL( TDes8* aEntry )

   460     {

   461 TFLOGSTRING("TSY: CMmONStoreTsy::ReadL");

   462     // Initialize ret value

   463     TInt ret( KErrArgument );

   464 

   465     if( sizeof( RMobileONStore::TMobileONEntryV1 ) <= aEntry->MaxLength() )

   466 	  	{

   467 

   468         // Unpack entry parameter

   469         RMobileONStore::TMobileONEntryV1Pckg* entryPckg =

   470             REINTERPRET_CAST

   471             ( RMobileONStore::TMobileONEntryV1Pckg*, aEntry );

   472         RMobileONStore::TMobileONEntryV1& entry = ( *entryPckg )();

   473 

   474         // Save entry pointer

   475         iReadONStoreEntryPtr = aEntry;

   476 

   477         // Forward request to GSM Extension

   478         ret = iMmONStoreExtInterface->ReadL( EMmTsyONStoreReadIPC, entry.iIndex );

   479 

   480         if ( KErrNone == ret )

   481             {

   482             // Save tsy req handle type

   483             iReqHandleType = EMultimodeONStoreRead;

   484             }

   485 	  	}

   486 

   487     return ret;

   488     }

   489 

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

   491 // CMmONStoreTsy::CompleteRead

   492 // Completes reading a entry from the ONStore

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

   494 // ---------------------------------------------------------------------------

   495 //

   496 void CMmONStoreTsy::CompleteRead(

   497     TInt aResult,

   498     CMmDataPackage* aDataPackage )

   499     {

   500 TFLOGSTRING("TSY: CMmONStoreTsy::CompleteRead");

   501     // Response information

   502     TONStoreMsg* ONStoreResp = NULL;

   503     // unpack data if exists

   504     if ( aDataPackage )

   505         {

   506         //unpack data

   507         aDataPackage->UnPackData( ONStoreResp );

   508         }

   509     else if ( KErrNone == aResult )

   510         {

   511 TFLOGSTRING("TSY: CMmONStoreTsy::CompleteRead result is KErrNone and aDataPackage is NULL!");

   512         aResult = KErrArgument;

   513         }

   514 

   515     // Reset req handle. Returns the deleted req handle

   516     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

   517         EMultimodeONStoreRead );

   518 

   519     if ( EMultimodeONStoreReqHandleUnknown != reqHandle )

   520         {

   521 

   522         if ( KErrNone == aResult )

   523             {

   524 

   525             // Get entry

   526             RMobileONStore::TMobileONEntryV1Pckg* entryPckg =

   527                 REINTERPRET_CAST( RMobileONStore::TMobileONEntryV1Pckg*,

   528                 iReadONStoreEntryPtr );

   529             RMobileONStore::TMobileONEntryV1& entry = ( *entryPckg )();

   530 

   531             // Fill entry

   532             // Map iIndex to client world (increase value by one)

   533             entry.iIndex = ONStoreResp->iLocation;

   534             entry.iText.Copy( ONStoreResp->iName );

   535             entry.iNumber.iTelNumber.Copy( ONStoreResp->iTelNumber );

   536 

   537             // SIM_PN_READ_RESP response

   538             entry.iMode = RMobilePhone::ENetworkModeUnknown;

   539             /*ENetworkModeUnknown,

   540             ENetworkModeUnregistered,

   541             ENetworkModeGsm,

   542             ENetworkModeAmps,

   543             ENetworkModeCdma,

   544             ENetworkModeWcdma

   545             */

   546             entry.iService = RMobilePhone::EServiceUnspecified;

   547             /*EServiceUnspecified,

   548             EVoiceService,

   549             EAuxVoiceService,

   550             ECircuitDataService,

   551             EPacketDataService,

   552             EFaxService,

   553             EShortMessageService,

   554             EAllServices

   555             */

   556 

   557             // Complete request to success

   558             ReqCompleted( reqHandle, KErrNone );

   559             }

   560         else

   561             {

   562             // Failure

   563             ReqCompleted( reqHandle, aResult );

   564             }

   565         }

   566     }

   567 

   568 // ---------------------------------------------------------------------------

   569 // CMmONStoreTsy::ReadCancel

   570 // Cancel read one ON store entry using index

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

   572 // ---------------------------------------------------------------------------

   573 //

   574 TInt CMmONStoreTsy::ReadCancel(

   575     const TTsyReqHandle aTsyReqHandle )

   576     {

   577 TFLOGSTRING("TSY: CMmONStoreTsy::ReadCancel");

   578     // Reset req handle. Returns the deleted req handle

   579     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

   580         EMultimodeONStoreRead );

   581 

   582     // Check that request handle was valid

   583     if ( EMultimodeONStoreReqHandleUnknown != reqHandle )

   584         {

   585         // Complete with KErrCancel

   586         ReqCompleted( aTsyReqHandle, KErrCancel );

   587         }

   588 

   589     return KErrNone;

   590     }

   591 

   592 // ---------------------------------------------------------------------------

   593 // CMmONStoreTsy::WriteL

   594 // Writes the entry supplied within the entry parameter into the store

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

   596 // ---------------------------------------------------------------------------

   597 //

   598 TInt CMmONStoreTsy::WriteL(

   599     const TTsyReqHandle aTsyReqHandle,

   600     TDesC8* aEntry )

   601     {

   602 TFLOGSTRING("TSY: CMmONStoreTsy::WriteL");

   603     // Save tsy req handle type

   604     iReqHandleType = EMultimodeONStoreWrite;

   605 

   606     // Unpack entry param to get the location

   607     RMobileONStore::TMobileONEntryV1Pckg* entryPckg =

   608         REINTERPRET_CAST

   609         ( RMobileONStore::TMobileONEntryV1Pckg*, aEntry );

   610     RMobileONStore::TMobileONEntryV1& entry = ( *entryPckg )();

   611 

   612     iWriteONStoreEntryPtr = aEntry;

   613     iWriteIndexToReturn = entry.iIndex;

   614 

   615     // It is not possible to cancel write request anymore...

   616     iIsWriteCancellingPossible = EFalse;

   617 

   618     // Return value

   619     TInt ret( KErrNone );

   620 

   621     ret = iMmONStoreExtInterface->

   622         WriteL(

   623         EMmTsyONStoreWriteIPC,

   624         aEntry );

   625 

   626     // Check error while processing write

   627     if ( KErrNone != ret )

   628         {

   629         iWriteIndexToReturn = 0;

   630         iWriteONStoreEntryPtr = NULL;

   631         ReqCompleted( aTsyReqHandle, ret );

   632         }

   633     else

   634         {

   635         // Save tsy req handle type

   636         iReqHandleType = EMultimodeONStoreWrite;

   637         }

   638 

   639     return KErrNone;

   640     }

   641 

   642 // ---------------------------------------------------------------------------

   643 // CMmONStoreTsy::CompleteWrite

   644 // Completes writing a entry to the phonebookstore

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

   646 // ---------------------------------------------------------------------------

   647 //

   648 void CMmONStoreTsy::CompleteWrite(

   649     TInt aResult,

   650     CMmDataPackage* aDataPackage )

   651     {

   652 TFLOGSTRING("TSY: CMmONStoreTsy::CompleteWrite");   

   653     // Reset req handle. Returns the deleted req handle

   654     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

   655         EMultimodeONStoreWrite );

   656 

   657     if ( EMultimodeONStoreReqHandleUnknown != reqHandle )

   658         {

   659         if ( KErrNone == aResult )

   660             {

   661             TInt location = 0;

   662             

   663             if ( aDataPackage )

   664                 {

   665                 aDataPackage->UnPackData( location );

   666                 }

   667                 

   668             // Complete notify store event

   669             iMobileONStoreEvent = ( RMobilePhoneStore::KStoreEntryAdded );

   670 

   671             // Return index within entry.iIndex, if needed

   672             if ( -1 == iWriteIndexToReturn )

   673                 {

   674                 // Unpack entry param

   675                 RMobileONStore::TMobileONEntryV1Pckg* entryPckg =

   676                     ( RMobileONStore::TMobileONEntryV1Pckg*

   677                     )iWriteONStoreEntryPtr;

   678                 RMobileONStore::TMobileONEntryV1& entry = ( *entryPckg )();

   679 

   680                 // Set the correct entry index

   681                 entry.iIndex = location;

   682                 }

   683             

   684             CompleteNotifyStoreEvent( location );

   685             }

   686 

   687         // Complete with error

   688         ReqCompleted( reqHandle, aResult );

   689         }

   690 

   691     iWriteIndexToReturn = 0;

   692     iWriteONStoreEntryPtr = NULL;

   693     }

   694 

   695 // ---------------------------------------------------------------------------

   696 // CMmONStoreTsy::WriteCancel

   697 // Cancels an outstanding Write method

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

   699 // ---------------------------------------------------------------------------

   700 //

   701 TInt CMmONStoreTsy::WriteCancel(

   702     const TTsyReqHandle aTsyReqHandle )

   703     {

   704 TFLOGSTRING("TSY: CMmONStoreTsy::WriteCancel");

   705     // Check if cancelling is possible. If not, return KErrNone

   706     if ( iIsWriteCancellingPossible )

   707         {

   708         // Reset req handle. Returns the deleted req handle

   709         TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

   710             EMultimodeONStoreWrite );

   711 

   712         if ( EMultimodeONStoreReqHandleUnknown != reqHandle )

   713             {

   714             iWriteIndexToReturn = 0;

   715             iWriteONStoreEntryPtr = NULL;

   716             ReqCompleted( aTsyReqHandle, KErrCancel );

   717             }

   718         }

   719 

   720     return KErrNone;

   721     }

   722 

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

   724 // CMmONStoreTsy::DeleteL

   725 // Deletes one ON entry by index supplied as a parameter

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

   727 // ---------------------------------------------------------------------------

   728 //

   729 TInt CMmONStoreTsy::DeleteL(

   730     const TTsyReqHandle aTsyReqHandle,

   731     TInt* aIndex )

   732     {

   733 TFLOGSTRING("TSY: CMmONStoreTsy::DeleteL");

   734     // Initialize ret value

   735     TInt ret( KErrGeneral );

   736 

   737     // Get index and decrease value (CS uses indexes '0' ->, SOS '1' ->)

   738     iDeleteONStoreIndex = *aIndex;

   739 

   740     // Check that entry index value is greater than zero

   741     if ( 0 < iDeleteONStoreIndex )

   742         {

   743         // Forward Delete request to gsm extension. Use Write function

   744         // to "erase" ON store entry

   745         ret = iMmONStoreExtInterface->DeleteL( EMmTsyONStoreDeleteIPC, 

   746             iDeleteONStoreIndex );

   747         }

   748 

   749     // Message construction failed or phonet sender returned error

   750     if ( KErrNone != ret )

   751         {

   752         ReqCompleted( aTsyReqHandle, ret );

   753         }

   754     else

   755         {

   756         // Save tsy request handle type

   757         iReqHandleType = EMultimodeONStoreDelete;

   758         }

   759 

   760     return KErrNone;

   761     }

   762 

   763 // ---------------------------------------------------------------------------

   764 // CMmONStoreTsy::CompleteDelete

   765 // Complete delete one ON entry by index

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

   767 // ---------------------------------------------------------------------------

   768 //

   769 void CMmONStoreTsy::CompleteDelete(

   770     TInt aResult )

   771     {

   772 TFLOGSTRING("TSY: CMmONStoreTsy::CompleteDelete");

   773     // Reset req handle. Returns the deleted req handle

   774     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

   775         EMultimodeONStoreDelete );

   776 

   777     // Check that request was valid

   778     if ( EMultimodeONStoreReqHandleUnknown != reqHandle )

   779         {

   780         // Complete with CS return value

   781         ReqCompleted( reqHandle, aResult );

   782 

   783         // If deletetion done succesfully, complete notify store event

   784         if ( KErrNone == aResult )

   785             {

   786             // Complete notify store event

   787             iMobileONStoreEvent = ( RMobilePhoneStore::KStoreEntryDeleted );

   788             CompleteNotifyStoreEvent( iDeleteONStoreIndex );

   789             }

   790         }

   791     }

   792 

   793 // ---------------------------------------------------------------------------

   794 // CMmONStoreTsy::DeleteAllL

   795 // Delete all ON store entries

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

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

   798 //

   799 TInt CMmONStoreTsy::DeleteAllL (

   800     const TTsyReqHandle aTsyReqHandle )

   801     {

   802 TFLOGSTRING("TSY: CMmONStoreTsy::DeleteAllL");

   803     // Init variable for DeleteAllPhase1

   804     iDeleteAllContinue = ETrue;

   805 

   806     // Forwarded extension call

   807     TInt ret = iMmONStoreExtInterface->DeleteAllL( 

   808         EMmTsyONStoreDeleteAllIPC );

   809 

   810     // Check is return value valid

   811     if ( KErrNone != ret )

   812         {

   813         // Complete with error

   814         ReqCompleted( aTsyReqHandle, ret );

   815         }

   816     else

   817         {

   818         // Save TSY request handle type

   819         iReqHandleType = EMultimodeONStoreDeleteAll;

   820         }

   821 

   822     return KErrNone;

   823     }

   824 

   825 // ---------------------------------------------------------------------------

   826 // CMmONStoreTsy::CompleteDeleteAllPhase1L

   827 // Complete delete all ON store entries phase 1

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

   829 // ---------------------------------------------------------------------------

   830 //

   831 void CMmONStoreTsy::CompleteDeleteAllPhase1L(

   832     TInt aResult )

   833     {

   834 TFLOGSTRING("TSY: CMmONStoreTsy::CompleteDeleteAllPhase1L");

   835     // Check that DeleteAll was called

   836     if ( iDeleteAllContinue )

   837         {

   838         if ( KErrNone == aResult )

   839             {

   840             // Empty variables in order to call Write-function

   841             TBuf<1> name;

   842             TBuf<1> telNumber;

   843 

   844 #ifdef REQHANDLE_TIMER

   845             // Set the new terminate time for deleting new entries from

   846             // ONStore. About 300ms/entry => about (15s)/(50entries) ->

   847             // x2 -> 30sec.

   848             iTsyReqHandleStore->PostponeTimeout( EMultimodeONStoreDeleteAll,

   849                 30 );

   850 #endif // REQHANDLE_TIMER

   851 

   852             // Forward Delete request to gsm extension. Use Write function

   853             // to start process to erase all ON store entries.

   854             // '0' means that first location will be deleted first

   855               }

   856         // If error from SIM Server

   857         else

   858             {

   859             CompleteDeleteAll( aResult );

   860             }

   861         }

   862     }

   863 

   864 // ---------------------------------------------------------------------------

   865 // CMmONStoreTsy::CompleteDeleteAll

   866 // Complete delete all ON store entries

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

   868 // ---------------------------------------------------------------------------

   869 //

   870 void CMmONStoreTsy::CompleteDeleteAll(

   871     TInt aResult )

   872     {

   873     // Reset request handle. Returns the deleted request handle

   874     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

   875         EMultimodeONStoreDeleteAll );

   876 

   877     // Check that deleted request handle was valid

   878     if ( EMultimodeONStoreReqHandleUnknown != reqHandle )

   879         {

   880 TFLOGSTRING("TSY: CMmONStoreTsy::CompleteDeleteAll");        

   881         // Complete with error

   882         ReqCompleted( reqHandle, aResult );

   883 

   884         // If deletion done succesfully, complete notify store event

   885         // Notify will complete if it was requested

   886         if ( KErrNone == aResult )

   887             {

   888             // Set notify reason, whole ON store deleted. Store empty.

   889             iMobileONStoreEvent = ( RMobilePhoneStore::KStoreEmpty );

   890             // Complete notify store event, with '-1' due that more than one

   891             // entries deleted.

   892             CompleteNotifyStoreEvent( -1 );

   893             }

   894         }

   895     else if(EMultimodeONStoreReqHandleUnknown !=

   896 				 iTsyReqHandleStore->GetTsyReqHandle(EMultimodeONStoreStoreAll ))

   897     	{

   898 TFLOGSTRING("TSY: CMmONStoreTsy::CompleteDeleteAll requested by StoreAllL.");

   899     	TInt ret (aResult);

   900 		    	

   901     	if(KErrNone == ret)

   902     		{

   903     		// ON store is now empty. Let's begin with reading store size to actually store all entries.

   904     		TInt writeAllIndex = -1; // Store index when writing all entries

   905     		TRAPD(err, ret = iMmONStoreExtInterface->ReadL(

   906     				EMmTsyONStoreWriteSizeIPC, writeAllIndex ));

   907 			if(err != KErrNone)

   908 				{

   909 				ret = err;

   910 				}

   911     		}

   912         if(KErrNone != ret)

   913         	{

   914         	CompleteStoreAll( ret );

   915         	}

   916     	}

   917     else

   918     	{

   919 TFLOGSTRING("TSY: CMmONStoreTsy::CompleteDeleteAll - the request has been cancelled or bad req handle");

   920     	}

   921     }

   922 

   923 // ---------------------------------------------------------------------------

   924 // CMmONStoreTsy::DeleteAllCancel

   925 // This method cancels an outstanding DeleteAll -request

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

   927 // ---------------------------------------------------------------------------

   928 //

   929 TInt CMmONStoreTsy::DeleteAllCancel(

   930     const TTsyReqHandle aTsyReqHandle )

   931     {

   932 TFLOGSTRING("TSY: CMmONStoreTsy::DeleteAllCancel");

   933     // Reset req handle. Returns the deleted req handle

   934     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

   935         EMultimodeONStoreDeleteAll );

   936 

   937     if ( EMultimodeONStoreReqHandleUnknown != reqHandle )

   938         {

   939         // Prevent DeleteAllPhase1

   940         iDeleteAllContinue = EFalse;

   941         // Complete with KErrCancel

   942         ReqCompleted( aTsyReqHandle, KErrCancel );

   943         }

   944 

   945     return KErrNone;

   946     }

   947 

   948 // ---------------------------------------------------------------------------

   949 // CMmONStoreTsy::GetInfoL

   950 // This method returns information about the ONStore

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

   952 // ---------------------------------------------------------------------------

   953 //

   954 TInt CMmONStoreTsy::GetInfoL(

   955     const TTsyReqHandle aTsyReqHandle,

   956     RMobileONStore::TMobileONStoreInfoV1* aInfo )

   957     {

   958 TFLOGSTRING("TSY: CMmONStoreTsy::GetInfoL");

   959 

   960     TInt ret( KErrNone );

   961 

   962     // if aInfo is not correct type, send KErrArgument to client and return

   963     if( RMobilePhoneStore::KETelMobileONStoreV1 != aInfo->ExtensionId() )

   964         {

   965         ReqCompleted( aTsyReqHandle, KErrArgument );

   966         return ret;

   967         }

   968 

   969    	// Don't send request if pb init is still ongoing

   970 	// instead send KErrNotReady to client

   971 	TBool done ( ETrue );

   972 TFLOGSTRING2( "TSY: CMmONStoreTsy::GetInfoL iPBList->GetNumberOfObjects() = %d", iMmPhone->PBList()->GetNumberOfObjects());

   973 

   974 	for( TInt i = 0; i < iMmPhone->PBList()->GetNumberOfObjects(); i++ )

   975 	    {

   976 	    CMmPhoneBookStoreTsy* pbStore = iMmPhone->PBList()->

   977 	        GetMmPBByIndex( i );

   978 TFLOGSTRING2( "TSY: CMmONStoreTsy::GetInfoL index = %d", i);    

   979 

   980 		if ( !pbStore->IsPBInitDone() 

   981 			  && ( pbStore->GetPhonebookType() == KADNPhoneBook

   982 		      || pbStore->GetPhonebookType() == KFDNPhoneBook )  )

   983 		    {

   984 TFLOGSTRING("TSY: CMmONStoreTsy::GetInfoL - ADN or FDN init not done");

   985 TFLOGSTRING("TSY: CMmONStoreTsy::GetInfoL - in !pbStore->IsPBInitDone()");

   986 			// init still ongoing

   987 			done = EFalse;

   988 			}

   989    		}

   990    				

   991     // Check if some PB is not initialized, if so send KErrNotReady to client   				

   992    	if ( !done )

   993 		{

   994 TFLOGSTRING("TSY: CMmONStoreTsy::GetInfoL - PBInit not done, return KErrNotReady");

   995 		ReqCompleted( aTsyReqHandle, KErrNotReady );

   996 		}

   997 	            

   998 	else

   999 		{

  1000 TFLOGSTRING("TSY: CMmONStoreTsy::GetInfoL - PBInit done, complete");

  1001         // Set get info internal pointer

  1002         iONStoreInfoChanged = aInfo;

  1003         

  1004         // Request to GSM extension, get used entries,

  1005         // -1 as a index param-> specified location param not needed

  1006         ret = iMmONStoreExtInterface->ReadL( EMmTsyONStoreGetInfoIPC, -1 );

  1007 

  1008         if ( KErrNone != ret )   // Message sending failed

  1009             {

  1010             ReqCompleted( aTsyReqHandle, ret );

  1011             }

  1012         else

  1013             {

  1014             iIsGetInfoActive = ETrue;

  1015             // Save tsy req handle type

  1016             iReqHandleType = EMultimodeONStoreGetInfo;

  1017             }

  1018 		}

  1019 

  1020     return KErrNone;

  1021     }

  1022 

  1023 // ---------------------------------------------------------------------------

  1024 // CMmONStoreTsy::CompleteGetInfo

  1025 // Completes GetInfo -request

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

  1027 // ---------------------------------------------------------------------------

  1028 //

  1029 void CMmONStoreTsy::CompleteGetInfo( 

  1030     TInt aResult,

  1031     CMmDataPackage* aDataPackage )

  1032     {

  1033 TFLOGSTRING2("TSY: CMmONStoreTsy::CompleteGetInfo - Result: %d", aResult );

  1034 

  1035     // The number of used entries

  1036     TServiceType serviceType;   

  1037     //unpack data

  1038     aDataPackage->UnPackData( serviceType );

  1039 

  1040     // Reset req handle. Returns the deleted req handle

  1041     TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

  1042         EMultimodeONStoreGetInfo );

  1043 

  1044     if ( EMultimodeONStoreReqHandleUnknown != reqHandle )

  1045         {

  1046 

  1047         // If request was not cancelled or no error from SIM

  1048         // give info to client

  1049         if ( KErrNone == aResult )

  1050             {

  1051             iONStoreInfo.iTotalEntries = serviceType.iNumOfEntries;

  1052             iONStoreInfo.iUsedEntries = serviceType.iUsedEntries;

  1053             iONStoreInfo.iNumberLen = serviceType.iNumLen;

  1054             iONStoreInfo.iTextLen = serviceType.iNameLen;

  1055 

  1056             *iONStoreInfoChanged = iONStoreInfo;

  1057 

  1058 TFLOGSTRING3("TSY: CMmONStoreTsy::CompleteGetInfo - Name: %S, Type: %d", &iONStoreInfoChanged->iName, iONStoreInfoChanged->iType );

  1059 TFLOGSTRING3("TSY: CMmONStoreTsy::CompleteGetInfo - Total entries: %d, Used entries: %d", iONStoreInfoChanged->iTotalEntries, iONStoreInfoChanged->iUsedEntries );

  1060 TFLOGSTRING3("TSY: CMmONStoreTsy::CompleteGetInfo - Max Number length: %d, Max Name length: %d", iONStoreInfoChanged->iNumberLen, iONStoreInfoChanged->iTextLen );

  1061             }

  1062 

  1063         // NULL the pointer to info supplied to TSY from the client

  1064         iONStoreInfoChanged = NULL;

  1065         iIsGetInfoActive = EFalse;

  1066     

  1067         // Complete with error

  1068         ReqCompleted( reqHandle, aResult );

  1069         }

  1070     }

  1071 

  1072 // ---------------------------------------------------------------------------

  1073 // CMmONStoreTsy::SetInfo

  1074 // This method initializes ONStore internal info parameters

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

  1076 // ---------------------------------------------------------------------------

  1077 //

  1078 void CMmONStoreTsy::SetInfo()

  1079     {

  1080 TFLOGSTRING("TSY: CMmONStoreTsy::SetInfo");

  1081     // The name of the store

  1082     iONStoreInfo.iName = KETelOwnNumberStore;

  1083 

  1084     // The maximum number of characters for the number in a phonebook entry

  1085     iONStoreInfo.iNumberLen = KNoInfoAvail;

  1086 

  1087     // The maximum number of characters for the text tag in a phonebook entry

  1088     iONStoreInfo.iTextLen = KMaxTextLength;

  1089 

  1090     // The type of entry in the phone-side store

  1091     iONStoreInfo.iType = RMobilePhoneStore::EOwnNumberStore;

  1092 

  1093     // Indicates the capabilities of the store

  1094     iONStoreInfo.iCaps = KONStoreCaps;

  1095 

  1096     // Indicates the current number of entries that may be held in this store

  1097     iONStoreInfo.iUsedEntries = KNoInfoAvail;

  1098 

  1099     // Indicates the total numbetr of entries

  1100     iONStoreInfo.iTotalEntries = KNoInfoAvail;

  1101     }

  1102 

  1103 // ---------------------------------------------------------------------------

  1104 // CMmONStoreTsy::GetInfoCancel

  1105 // This method cancels an outstanding GetInfo -request

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

  1107 // ---------------------------------------------------------------------------

  1108 //

  1109 TInt CMmONStoreTsy::GetInfoCancel(

  1110     const TTsyReqHandle aTsyReqHandle )

  1111     {

  1112 TFLOGSTRING("TSY: CMmONStoreTsy::GetInfoCancel");

  1113 

  1114     iTsyReqHandleStore->ResetTsyReqHandle( EMultimodeONStoreGetInfo );

  1115 

  1116     // Complete with KErrCancel

  1117     ReqCompleted( aTsyReqHandle, KErrCancel );

  1118 

  1119     return KErrNone;

  1120     }

  1121 

  1122 // ---------------------------------------------------------------------------

  1123 // CMmONStoreTsy::NotifyStoreEvent

  1124 // This method activates notifying of ONStore events

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

  1126 // ---------------------------------------------------------------------------

  1127 //

  1128 TInt CMmONStoreTsy::NotifyStoreEvent(

  1129     RMobilePhoneStore::TMobileStoreEvent* aEvent,

  1130     TInt* aIndex )

  1131     {

  1132 TFLOGSTRING("TSY: CMmONStoreTsy::NotifyStoreEvent");

  1133     TTsyReqHandle requestHandle = iTsyReqHandleStore->GetTsyReqHandle( 

  1134         EMultimodeONStoreNotifyStoreEvent );