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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

//  INCLUDE FILES

#include "cmmphonebookstoretsy.h"

#include "cmmpblist.h"

#include "cmmphonebookstoregsmext.h"

#include "CMmCustomTsy.h"

#include <ctsy/tflogger.h>

#include <ctsy/rmmcustomapi.h>

#include "cmmmessagemanagerbase.h"

#include "cmmtsyreqhandlestore.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include "CMmCommonStaticUtility.h"

#include <ctsy/serviceapi/gsmerror.h>

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

CMmPhoneBookStoreTsy::CMmPhoneBookStoreTsy()

    {

    }

void CMmPhoneBookStoreTsy::ConstructL( const TDesC& aName )

    {

TFLOGSTRING("TSY: CMmPhoneBookStoreTsy::ConstructL - entered");

#ifdef REQHANDLE_TIMER

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this,

        iMmPhoneTsy,

        EMmTsyNumOfStorageRequests,

        iStorageReqHandles);

#else

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL(

        EMmTsyNumOfStorageRequests, iStorageReqHandles );

#endif

    // Get mode of current extension.

    RMobilePhone::TMobilePhoneNetworkMode currentMode;

    iMmPhoneTsy->GetStaticExtensionMode( &currentMode );

    // Reset all CMmPhoneBookStoreTsy variables

    ResetVariables();

    // Create GSM ENStore objects

    iMmPhoneBookStoreExtInterface =

        static_cast<CMmPhoneBookStoreExtInterface*>

            (CMmPhoneBookStoreGsmExt::NewL( this ) );

    // Set phonebook type by name

    SetPhoneBookType( aName );

    // Set extension mode

    SetActivePBExtension( iMmPhoneBookStoreExtInterface );

    // Set phonebookrelated name and number max values

    SetMaxNameAndNumLenght();

TFLOGSTRING2("TSY: CMmPhoneBookStoreTsy::ConstructL - PB %S", &iPhoneBookName);

    // Used entries is zero in the start

    iUsedEntries = 0;

    // Create bootState

    CMmPhoneTsy::CNosBootState* bootState = iMmPhoneTsy->NosBootState();

    //Create Read Store

    iReadReqStore = new ( ELeave ) TReadRequestStore();

    //Init

    iRetFillBufferedDes = KErrNone;

    iReadReqStore->iCaching = EFalse;

    iRequestedOnPBRead = EFalse;

    iIsPBInitCompleted = EFalse;

TFLOGSTRING2("TSY: CMmPhoneBookStoreTsy::ConstructL - iIsPhonebookInitialized: %i", iStoreInfoData->iIsPhonebookInitialized);

TFLOGSTRING2("TSY: CMmPhoneBookStoreTsy::ConstructL - iSIMReady: %i", bootState->iSIMReady);

TFLOGSTRING("TSY: CMmPhoneBookStoreTsy::ConstructL - before initialization");

    // Check if phonebook has been initialized

    if ( !iMmPhoneTsy->IsPBInitActive()

        && ( !iStoreInfoData->iIsPhonebookInitialized )

        && bootState->iSIMReady)

        {

TFLOGSTRING("TSY: CMmPhoneBookStoreTsy::ConstructL - starting initialization");

        // before phonebook requests, phonebook must be initialized

        iMmPhoneBookStoreExtInterface->InitPhonebook(

            EMmTsyPhoneBookStoreInitIPC, iPhoneBookName );

        iMmPhoneTsy->SetPBInitActiveStatus( ETrue );

        }

    if ( bootState->iSIMReady && iStoreInfoData->iIsPhonebookInitialized

        && ( iPhoneBookType == KADNPhoneBook

        || iPhoneBookType == KFDNPhoneBook ) )

        {

	  	// Set initialization flag 

        iIsPBInitCompleted = ETrue;

TFLOGSTRING("TSY: CMmPhoneBookStoreTsy::ConstructL - starting caching");

        // Call CacheEntries method to read entries from SIM.

        CacheEntriesL();

        }

    }

CMmPhoneBookStoreTsy* CMmPhoneBookStoreTsy::NewL(

    CMmPhoneTsy* aMmPhone,

    const TDesC& aName )

    {

TFLOGSTRING("TSY: CMmPhoneBookStoreTsy::NewL - entered");

    CMmPhoneBookStoreTsy* mmPhoneBookStoreTsy =

        new ( ELeave ) CMmPhoneBookStoreTsy();

    CleanupClosePushL( *mmPhoneBookStoreTsy );

    mmPhoneBookStoreTsy->iMmPhoneTsy = aMmPhone;

    mmPhoneBookStoreTsy->iPhoneBookName = aName;

    mmPhoneBookStoreTsy->ConstructL( aName );

    CleanupStack::Pop( mmPhoneBookStoreTsy );

    return mmPhoneBookStoreTsy;

    }

CMmPhoneBookStoreTsy::~CMmPhoneBookStoreTsy()

    {

TFLOGSTRING2("TSY: CMmPhoneBookStoreTsy::~CMmPhoneBookStoreTsy - PB %S", &iPhoneBookName);

    if ( iMmPhoneTsy )

        {

        CMmPhoneTsy::CNosBootState* bootState = iMmPhoneTsy->NosBootState();

        if ( iMmPhoneTsy->GetCustomTsy() )

            {

            RMmCustomAPI::TPndCacheStatus fdnCacheStatus = 

            iMmPhoneTsy->GetCustomTsy()->GetPhonebookCacheStatus( KFDNPhoneBook );

TFLOGSTRING2("TSY: CMmPhoneBookStoreTsy::~CMmPhoneBookStoreTsy - FDN cachestatus %d", fdnCacheStatus);

            RMmCustomAPI::TPndCacheStatus adnCacheStatus =

            iMmPhoneTsy->GetCustomTsy()->GetPhonebookCacheStatus( KADNPhoneBook );

TFLOGSTRING2("TSY: CMmPhoneBookStoreTsy::~CMmPhoneBookStoreTsy - ADN cachestatus %d", adnCacheStatus);

            // Check if the caching is active

            if ( bootState->iCachingActive )

                {

                // Check if the phonebook type is either ADN or FDN

                if ( KFDNPhoneBook == iPhoneBookType

                        || KADNPhoneBook == iPhoneBookType )

                    {

                    // Check if the cache status is either failed or not ready

                    if ( RMmCustomAPI::ECacheNotReady == fdnCacheStatus

                            || RMmCustomAPI::ECacheFailed == fdnCacheStatus

                            || RMmCustomAPI::ECacheNotReady == adnCacheStatus 

                            || RMmCustomAPI::ECacheFailed == adnCacheStatus )

                        {

                        //Create package

                        CPhoneBookDataPackage package;

                        // Set package data

                        package.SetPhoneBookName( iPhoneBookName );

                        TRAP_IGNORE( iMmPhoneTsy->MessageManager()->HandleRequestL( 

                                EMmTsyPhoneBookStoreCacheCancelIPC, &package ); );

                        TFLOGSTRING2("TSY: CMmPhoneBookStoreTsy::~CMmPhoneBookStoreTsy - CacheCancel for %d", iPhoneBookType);

                        TFLOGSTRING("TSY: CMmPhoneBookStoreTsy::~CMmPhoneBookStoreTsy - CachingActive = EFalse");

                        bootState->iCachingActive = EFalse;

                        }

                    }

                if ( (( RMmCustomAPI::ECacheNotReady == fdnCacheStatus

                        || RMmCustomAPI::ECacheFailed == fdnCacheStatus ) && (KADNPhoneBook == iPhoneBookType) )

                        || (( RMmCustomAPI::ECacheNotReady == adnCacheStatus

                                || RMmCustomAPI::ECacheFailed == adnCacheStatus )) && (KFDNPhoneBook == iPhoneBookType) )  

                    {

                    TFLOGSTRING("TSY: CMmPhoneBookStoreTsy::~CMmPhoneBookStoreTsy - CachingActive = ETrue");

                    // Set the caching back to active

                    bootState->iCachingActive = ETrue;                 

                    }

                }

            }

        }

    if ( iTsyReqHandleStore )

        {

        delete iTsyReqHandleStore;

        iTsyReqHandleStore = NULL;

        }

    if ( iMmPhoneTsy )

        {

        // Remove this phonebook from the list of PB's

        iMmPhoneTsy->PBList()->RemoveObject( this );

        }

    // Delete PhoneBookStoreGsmExt

    if ( iMmPhoneBookStoreExtInterface )

        {

        delete iMmPhoneBookStoreExtInterface;

        iMmPhoneBookStoreExtInterface = NULL;

        }

    // Delete phonebook write entry

    if ( iWriteEntry )

        {

        delete iWriteEntry;

        iWriteEntry = NULL;

        }

    // Delete phonebook delete entry

    if ( iDeleteEntry )

        {

        delete iDeleteEntry;

        iDeleteEntry = NULL;

        }

    // Delete cache

    if ( iPBStoreCache )

        {

		/*

		 * When using the NON-DISPATCHER version, CTSY copies overthe contents of the LTSYs Phonebook Store Cache.

		 * This is becasue the LTSY Phonebook Store Cache is destroyed when the complete request of the phonebook

		 * store read cache is finished. CTSY needs this information to stay alive longer. The problem doesn't exist

		 * when using the dispatcher as this information is contained within it for the lifetime of the dispatcher

		 * or until it's destroyed but CTSY is aware of this.

		 */

#ifndef USING_CTSY_DISPATCHER

        iPBStoreCache->ResetAndDestroy();

        delete iPBStoreCache;

#endif //USING_CTSY_DISPATCHER

        iPBStoreCache = NULL;

        }

    //if new cache was requested on Read, Store must be deleted here

    if ( iReadReqStore )

        {

        delete iReadReqStore;

        iReadReqStore = NULL;

        }

    // Set cache ready status to Not Ready

    ResetCacheReady();

    }

// ---------------------------------------------------------------------------

// CMmPhoneBookStoreTsy::Phone

// Returns pointer to the Multimode Phone object. For internal use.

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

// ---------------------------------------------------------------------------

//

CMmPhoneTsy* CMmPhoneBookStoreTsy::Phone()

    {

    return iMmPhoneTsy;

    }

// ---------------------------------------------------------------------------

// CMmPhoneBookStoreTsy::Init

// Initialisation method that is called from ETel Server.

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

// ---------------------------------------------------------------------------

//

void CMmPhoneBookStoreTsy::Init()

    {

    }

// ---------------------------------------------------------------------------

// CMmPhoneBookStoreTsy::OpenNewObjectByNameL

// This method is not supported.

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

// ---------------------------------------------------------------------------

//

CTelObject* CMmPhoneBookStoreTsy::OpenNewObjectByNameL( const TDesC& )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

// ---------------------------------------------------------------------------

// CMmPhoneBookStoreTsy::OpenNewObjectL

// This method is not supported.

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

// ---------------------------------------------------------------------------

//

CTelObject* CMmPhoneBookStoreTsy::OpenNewObjectL( TDes& )

    {

    User::Leave( KErrNotSupported );

    return NULL;

    }

// ---------------------------------------------------------------------------

// CMmPhoneBookStoreTsy::ReqModeL

// ReqModeL is called from the server's CTelObject::ReqAnalyserL

// in order to check the type of request it has.

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

// ---------------------------------------------------------------------------

//

CTelObject::TReqMode CMmPhoneBookStoreTsy::ReqModeL(

    const TInt aIpc )

    {

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

    CTelObject::TReqMode ret = 0;

    switch ( aIpc )

        {

        // Flow Controlled Services

        case EMobilePhoneStoreDelete:

        case EMobilePhoneStoreDeleteAll:

            ret=KReqModeFlowControlObeyed;

            break;

        // Multiple Completion Services with Immediate Server Repost

        // (Usually Notifications)

        case EMobilePhoneStoreNotifyStoreEvent:

            ret = KReqModeMultipleCompletionEnabled |

                KReqModeRePostImmediately;

            break;

        // Methods that can propably take a long time and cannot therefore be

        // flow controlled. Solution: All these methods must check req handle

        // table before handling the request. In case that the request table

        // indicates that same method has been called and has not been

        // completed, the method should return KErrServerBusy.

        case EMobilePhoneBookStoreRead:

        case EMobilePhoneBookStoreWrite:

            ret = 0;

            break;

        // Methods that are using DOS but have own flow control system

        case EMobilePhoneStoreGetInfo:

            ret = 0;

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    return ret;

    }

// ---------------------------------------------------------------------------

// CMmPhoneBookStoreTsy::RegisterNotification

// RegisterNotification is called when the server recognises

// that this notification is being posted for the first time on this

// sub-session object. It enables the TSY to "turn on" any regular

// notification messages that it may receive from DOS. Currently does not

// really do anything but returns KErrNone to ETel server in case of known

// notification request type.

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

// ---------------------------------------------------------------------------

//

TInt CMmPhoneBookStoreTsy::RegisterNotification(

    const TInt aIpc )

    {

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobilePhoneStoreNotifyStoreEvent:

            // KErrNone

            break;

        default:

            // Unknown or invalid IPC

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

// ---------------------------------------------------------------------------

// CMmPhoneBookStoreTsy::DeregisterNotification

// DeregisterNotification is called when the server recognises

// that this notification will not be posted again because the last client

// to have a handle on this sub-session object has just closed the handle.

// It enables the TSY to "turn off" any regular notification messages that

// it may receive from DOS. Currently does not really do anything but returns

// KErrNone to ETel server in case of known notification request type.

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

// ---------------------------------------------------------------------------

//

TInt CMmPhoneBookStoreTsy::DeregisterNotification(

    const TInt aIpc )

    {

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobilePhoneStoreNotifyStoreEvent:

            // KErrNone

            break;

        default:

            // Unknown or invalid IPC

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

// ---------------------------------------------------------------------------

// CMmPhoneBookStoreTsy::NumberOfSlotsL

// NumberOfSlotsL is called by the server when it is registering a

// new NOTIFICATION. It enables the TSY to tell the server

// how many buffer slots to allocate for "repost immediately" notifications

// that may trigger before clients collect them.

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

// ---------------------------------------------------------------------------

//

TInt CMmPhoneBookStoreTsy::NumberOfSlotsL(

    const TInt aIpc )

    {

    TInt numberOfSlots = 1; // number of slots

    switch ( aIpc )

        {

        case EMobilePhoneStoreNotifyStoreEvent:

            numberOfSlots = KMmPhoneStoreNotifyStoreEventSlots;

            break;

        default:

            // Unknown or invalid Storage IPC

            User::Leave( KErrNotSupported );

            break;

        }

    return numberOfSlots;

    }

// ---------------------------------------------------------------------------

// CMmPhoneBookStoreTsy::CancelService

// CancelService is called by the server when it is

// "cleaning-up" any still outstanding asynchronous requests before closing

// a client's sub-session. This will happen if a client closes its R-class

// handle without cancelling outstanding asynchronous requests. Only

// Mobile API requests are handled here.

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

// ---------------------------------------------------------------------------

//

TInt CMmPhoneBookStoreTsy::CancelService(

    const TInt aIpc,

    const TTsyReqHandle aTsyReqHandle )

    {

TFLOGSTRING3("TSY: CMmPhoneBookStoreTsy::CancelService IPC:%d Handle:%d", aIpc, aTsyReqHandle);

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobilePhoneStoreGetInfo:

            ret = GetInfoCancel( aTsyReqHandle );

            break;

        case EMobilePhoneBookStoreRead:

            ret =  ReadCancel( aTsyReqHandle );

            break;

        case EMobilePhoneStoreDelete:

        case EMobilePhoneBookStoreWrite:

        case EMobilePhoneStoreDeleteAll:

            // These request can't be cancelled, because no

            // functionality for cancelling. So everything

            // to do, is let the request continue and return KErrNone.

            ret = KErrNone;

            break;

        case EMobilePhoneStoreNotifyStoreEvent:

            ret =  NotifyStoreEventCancel( aTsyReqHandle );

            break;

        default:

            break;

        }

TFLOGSTRING2("TSY: CMmPhoneBookStoreTsy::CancelService return: %d", ret);

    return ret;

    }

// ---------------------------------------------------------------------------

// CMmPhoneBookStoreTsy::ExtFunc

// Dispatches extension function requests. All functions that are not

// part of the core function set, are routed via the ExtFunc method.

// At the beginning of this method, packaged pointers are unpacked. Then

// the correct function is selected using the IPC number.

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

// ---------------------------------------------------------------------------

//

TInt CMmPhoneBookStoreTsy::ExtFunc(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

TFLOGSTRING3("TSY: CMmPhoneBookStoreTsy::ExtFunc IPC:%d Handle:%d", aIpc, aTsyReqHandle);

    TInt ret = KErrNone;

    TInt trapError = KErrNone;

    // Reset last tsy request type

    iReqHandleType = EMultimodePhoneBookStoreReqHandleUnknown;

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

    if ( KErrNone != trapError )

        {

        ReqCompleted( aTsyReqHandle, trapError );

        }

    else if ( KErrNone != ret )

        {

        ReqCompleted( aTsyReqHandle, ret );

        }

    // Save request handle

    if ( EMultimodePhoneBookStoreReqHandleUnknown != iReqHandleType )

        {

#ifdef REQHANDLE_TIMER

        SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

#else

        iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, aTsyReqHandle );

#endif

        }