/*

* Copyright (c) 2009-2010 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:  Implementation of the CVmbxPbkStore class

*

*/

// INCLUDE FILES

#include <commonphoneparser.h>

#include <mpbutil.h>

#include <cvoicemailboxentry.h>

#include "vmbxutilities.h"

#include "vmbxetelconnection.h"

#include "vmbxlogger.h"

#include "vmbxpbkstore.h"

#include <e32property.h>

#include <simutils.h>

#include <startupdomainpskeys.h>

//CONSTANTS

// Amount of retries to be performed.

const TInt KVmbxPhonebookBufferSize( 150 );

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

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

// CVmbxPbkStore::CVmbxPbkStore

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

// might leave.

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

//

CVmbxPbkStore::CVmbxPbkStore(): CActive(EPriorityStandard ),

                                iAsynType( EVmbxSimDefault )

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::CVmbxPbkStore =>" );

    CActiveScheduler::Add( this );

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::CVmbxPbkStore <=" );

    }

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

// CVmbxPbkStore::~CVmbxPbkStore

// destructor

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

//

CVmbxPbkStore:: ~CVmbxPbkStore()

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::~CVmbxPbkStore =>" );

    Cancel();

    iPhoneBook.Close();

    delete iWait;

    delete iETelConnection;

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::~CVmbxPbkStore <=" );

    }

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

// CVmbxPbkStore::NewL

// two phase constructor

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

//

CVmbxPbkStore* CVmbxPbkStore::NewL()

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::NewL =>" );

    CVmbxPbkStore* self = new( ELeave ) CVmbxPbkStore();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::NewL <=" );

    return self;

    }

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

// CVmbxPbkStore::ConstructL

// two phase constructor

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

//

void CVmbxPbkStore::ConstructL()

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::ConstructL =>" );

    TInt value( 0 );

    TInt res = RProperty::Get( KPSUidStartup, KPSSimStatus, value );

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::ConstructL res = %d", res );

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::ConstructL value = %d", value );

    if ( (ESimUsable != value && ESimReadable != value ) || KErrNone != res )

        {

        // Sim card not ready to use

        User::Leave( KErrNotReady );

        }

    // Open tel server and phone

    iETelConnection = CVmbxETelConnection::NewL();

    iWait = new( ELeave ) CActiveSchedulerWait; 

    TVmbxAlsLineType alsLine = VmbxUtilities::AlsLine();

    // Supported ALS line,ALS line on

    if ( EVmbxAlsLineDefault != alsLine )

        {

        // open 6f17 file ,if not found the file, leave

        User::LeaveIfError( OpenVmbxPhonebook() );

        }

    // Not supported ALS line,ALS line off

    else

        {

        // Open 6fc7 file, if not found, open 6f17 file

        TInt result = OpenMbdnPhonebook();

        if ( KErrPathNotFound == result )

            {

            //close 6fc7 and open 6f17 file

            iPhoneBook.Close();

            // open 6f17 file ,if not found the file, leave

            User::LeaveIfError( OpenVmbxPhonebook() );

            }

        else

            {

            User::LeaveIfError( result );

            }

        }

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::ConstructL <=" );

    }

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

// CVmbxPbkStore::GetVmbxInfo

// Activates phonebook info query

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

TInt CVmbxPbkStore::GetVmbxInfo( 

        RMobilePhoneBookStore::TMobilePhoneBookInfoV1& aInfo )

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::GetVmbxInfo =>" );

    TInt result( KErrInUse );

    RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg

                                            InfoPckg( aInfo );

    // get Info from phonebook

    if( !IsActive() && !iWait->IsStarted() )

        {

        iPhoneBook.GetInfo( iStatus, InfoPckg );

        iAsynType = EVmbxSimGetInfo;

        SetActive();

        iWait->Start();

        result = iStatus.Int();

        VMBLOGSTRING2( "VMBX: CVmbxPbkStore::PhonebookInfo: \

                SIM Phonebook info read, status: %I", result );

        }

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::GetVmbxInfo <=" );

    return result;

    }

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

// CVmbxPbkStore::IsWritable

// Sim write support

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

//

TBool CVmbxPbkStore::IsWritable()

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::IsWritable =>" );

    TBool result( EFalse );

    if ( IsWriteAccess() )

        {

        // Get current sim entry, then write the same entry 

        // to sim if read successufully

        CVoiceMailboxEntry* simEntry(NULL);

        TRAPD( newErr, simEntry = CVoiceMailboxEntry::NewL() );

        VMBLOGSTRING2( "VMBX: CVmbxPbkStore::IsWritable newErr = %d ",

            newErr );

        if ( KErrNone == newErr )

            {

            // get als line info

            simEntry->SetVmbxAlsLineType( VmbxUtilities::AlsLine() );

            simEntry->SetVoiceMailboxType( EVmbxVoice );

            simEntry->SetServiceId( KVmbxServiceVoice );

            TRAPD( err, SimReadL( *simEntry ) );

            VMBLOGSTRING2( "VMBX: CVmbxPbkStore:: IsWritable read %I <=", err );

            if ( KErrNotFound == err )

                {

                simEntry->SetVmbxNumber( KNullDesC );

                }

            if ( KErrNone == err || KErrNotFound == err )

                {

                err = Write( *simEntry );

                VMBLOGSTRING2( "VMBX: CVmbxPbkStore:: IsWritable write %I <=",

                    err );

                // If write successfully, means writable

                if ( KErrNone == err )

                    {

                    result = ETrue;

                    }

                 }

           }

        delete simEntry;

        simEntry = NULL;

        }

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore:: IsWritable result %I <=", result );

    return result;

    }

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

// CVmbxPbkStore::PhoneBookType

// PhoneBookType

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

//

TVmbxSimPhonebookType CVmbxPbkStore::PhoneBookType()

    {

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::PhoneBookType type %I", 

                         iPhoneBookType );

    return iPhoneBookType;

    }

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

// CVmbxPbkStore::Write

// Write to SIM

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

//

TInt CVmbxPbkStore::Write( const CVoiceMailboxEntry& aEntry )

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::Write =>" );

    TInt result( KErrInUse );

    TBuf8<KVmbxPhonebookBufferSize> pbData;

    CPhoneBookBuffer* pbkBuffer = new CPhoneBookBuffer();

    if ( !pbkBuffer )

        {

        VMBLOGSTRING( "VMBX: CVmbxPbkStore::Write: \

        Phonebook creation error" );

        result = KErrNoMemory;

        }

    else

        {

        pbkBuffer->Set( &pbData );

        TInt activeAlsLine = aEntry.VmbxAlsLineType();

        // Add index, const value for vmbx write.

        int entryIndex = 1;

        // New entry

        result = pbkBuffer->AddNewEntryTag();

        if ( KErrNone == result )

            {

            // Type of index is TUint16 in Multimode ETel and TInt in old ETel.

            result = pbkBuffer->PutTagAndValue( 

            RMobilePhoneBookStore::ETagPBAdnIndex, (TUint16)entryIndex );

            VMBLOGSTRING2( "VMBX: CVmbxPbkStore::Write: ETagPBAdnIndex \

                    result=%I",  result );

            TPtrC vmbxNumber( KNullDesC );

            }

        if ( KErrNone == result )

            {

            if ( iPhoneBookType == EMBDNPhoneBook )

                {

                RMobilePhone::TMobilePhoneVoicemailIdsV3 mbdnInfo;

                result = GetMbdnInfo( VmbxUtilities::AlsLine(), mbdnInfo );

                if ( KErrNone == result )

                    {

                    TInt index = mbdnInfo.iVoice;

                    if( !IsActive() && !iWait->IsStarted() )

                        {

                        // write vmbx number to 6fc7 file

                        iPhoneBook.Write( iStatus, pbData, index );

                        // Wait for asynchronous call to finish

                        iAsynType = EVmbxSimEntryWrite;

                        SetActive();

                        iWait->Start();

                        result = iStatus.Int();

                        }

                    }

                VMBLOGSTRING( "Mbdn writing" );

                }

            else

                {

                if( !IsActive() && !iWait->IsStarted() )

                    {

                    // write vmbx number to 6f17 file

                    iPhoneBook.Write( iStatus, pbData, entryIndex );

                    iAsynType = EVmbxSimEntryWrite;

                    // Wait for asynchronous call to finish

                    SetActive();

                    iWait->Start();

                    result = iStatus.Int();

                    }

                VMBLOGSTRING( "CVmbxPbkStore::Write 6f17 writing" );

                }

            }

        }

    delete pbkBuffer;

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::Write: result=%I<=",  result );

    return result;

    }

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

// CVmbxPbkStore::PhonebookStore

// Return RMobilePhoneBookStore

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

RMobilePhoneBookStore& CVmbxPbkStore::PhonebookStore()

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::PhonebookStore <=>" );

    return iPhoneBook;

    }

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

// CVmbxPbkStore::GetMbdnInfo

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

//

TInt CVmbxPbkStore::GetMbdnInfo( const TVmbxAlsLineType aAlsLine,

            RMobilePhone::TMobilePhoneVoicemailIdsV3& aInfo )

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::GetMbdnInfo =>" );

    TInt result( KErrInUse );

    // Get identifiers

    if ( !IsActive() && !iWait->IsStarted() )

        {

        VMBLOGSTRING( "VMBX: CVmbxPbkStore::GetMbdnInfo: GetMailboxNumbers" );

        VMBLOGSTRING2( "VMBX: CVmbxPbkStore::GetMbdnInfo: iStatus %I",

                                                             iStatus.Int() );

        RMobilePhone::TMobilePhoneVoicemailIdsV3Pckg infoPckg( aInfo );

        iETelConnection->Phone().GetMailboxNumbers( iStatus, infoPckg );

        VMBLOGSTRING2( "VMBX: CVmbxPbkStore::GetMbdnInfo :iStatus %I",

                                                             iStatus.Int() );

        iAsynType = EVmbxSimMbdnInfo;

        // Wait for asynchronous call to finish

        SetActive();

        iWait->Start();

        VMBLOGSTRING2( "VMBX: CVmbxPbkStore::GetMbdnInfo: iVoice value %I",

                                                             aInfo.iVoice );

        if ( iStatus.Int() == KErrNotFound )

            {

            result = KErrNone;

            VMBLOGSTRING( "VMBX: CVmbxPbkStore::GetMbdnInfo: KErrNotFound,\

             but igorned and change to KErrNone" );

            }

        else

            {

            result = iStatus.Int();

            }

        if ( EVmbxAlsLineDefault == aAlsLine )

            {

            aInfo.iVoice =  EVmbxAlsLine1;

            }

        VMBLOGSTRING2( "VMBX: CVmbxPbkStore::GetMbdnInfo: aInfo.iVoice %I",

            aInfo.iVoice );

        }

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::GetMbdnInfo: result %I<=",

         result );

    return result;

    }

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

// CVmbxPbkStore::OpenMbdnPhonebook

// opening mbdn-type phonebook

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

//   

TInt CVmbxPbkStore::OpenMbdnPhonebook()

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::OpenMbdnPhonebook =>" );

    //Open mbdn-type phonebook , Currently the file not exist, thr return

    // value also KErrNone

    TInt result = iPhoneBook.Open( iETelConnection->Phone(),

                                         KETelIccMbdnPhoneBook );

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::OpenMbdnPhonebook :\

        MBDN opening result = %d", result );

    TBool res = IsSimFileExisting( EMBDNPhoneBook );

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::OpenMbdnPhonebook :\

        MBDN reading res = %d", res );

    if ( !res )

        {

        result = KErrPathNotFound;

        }

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::OpenMbdnPhonebook res = %d<=", result );

    return result;

    }

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

// CVmbxPbkStore::OpenVmbxPhonebook

// opening vmbx-type phonebook

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

//

TInt CVmbxPbkStore::OpenVmbxPhonebook()

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::OpenVmbxPhonebook =>" );

    //Open vmbx-type phonebook , Currently the file not exist, thr return

    // value also KErrNone

    TInt result = iPhoneBook.Open( iETelConnection->Phone(),

                                                 KETelIccVoiceMailBox );

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::OpenVmbxPhonebook :\

        Vmbx opening result = %d", result );

    TBool res = IsSimFileExisting( EVMBXPhoneBook );

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::OpenVmbxPhonebook :\

        Vmbx reading res = %d", res );

    if ( !res )

        {

        result = KErrPathNotFound;

        }

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::OpenVmbxPhonebook result=%d <=", result );

    return result;

    }

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

// CVmbxPbkStore::GetL

// Fetches mailbox number from Sim

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

//

void CVmbxPbkStore::GetL( CVoiceMailboxEntry& aEntry )

    {

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::GetL: iPhoneBookType %d=>",

                         iPhoneBookType );

    if ( EMBDNPhoneBook == iPhoneBookType )

        {

        TRAPD( err, SimReadL( aEntry ) );

        TPtrC vmbxNumber( KNullDesC );

        if ( KErrNone == err )

            {

            err = aEntry.GetVmbxNumber( vmbxNumber );

            }

        // 6fc7 file empty

        if ( ( KErrNone != err ) || ( !vmbxNumber.Length() ) )

            {

            VMBLOGSTRING2( "VMBX: CVmbxPbkStore::GetL: \

            no vmbx number in 6fc7 file then read from 6f17 file err%I", err );

            // close 6fc7 and open 6f17 file

            iPhoneBook.Close();

            User::LeaveIfError( OpenVmbxPhonebook() );

            // read vmbx number from 6f17 file

            SimReadL( aEntry );

            }

        }

    else

        {

        SimReadL( aEntry );

        }

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::GetL <=" );

    }

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

// CVmbxPbkStore::SimReadL

// read vmbx number from sim

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

//

void CVmbxPbkStore::SimReadL( CVoiceMailboxEntry& aEntry )

    {

    VMBLOGSTRING( "VMBX: CVmbxPbkStore::SimReadL =>" );

    TInt numEntries( 1 );

    TBuf8<KVmbxPhonebookBufferSize> pbData;

    TInt result( KErrInUse );

    if ( iPhoneBookType == EMBDNPhoneBook )

        {

        RMobilePhone::TMobilePhoneVoicemailIdsV3 mbdnInfo;

        result = GetMbdnInfo( EVmbxAlsLine1, mbdnInfo );

        if ( KErrNone == result )

            {

            VMBLOGSTRING( "start MBDN PhoneBook read" );

            if( !IsActive() && !iWait->IsStarted() )

                {

                // read vmbx number from 6fc7 file

                iPhoneBook.Read( 

                iStatus, mbdnInfo.iVoice, numEntries, pbData );

                iAsynType = EVmbxSimEntryRead;

                // Wait for asynchronous call to finish

                SetActive();

                iWait->Start();

                }

            }

        }

    else

        {

        // Record#1 in sim is for line1 number and Record#2 in sim is for

        // line2 number so line is used to fetch

        VMBLOGSTRING( "start VMBX PhoneBook read" );

        TInt activeAlsLine = aEntry.VmbxAlsLineType();

        if ( EVmbxAlsLineDefault == activeAlsLine )

            {

            activeAlsLine = EVmbxAlsLine1;

            }

         if( !IsActive() && !iWait->IsStarted() )

            {

            result = KErrNone;

            // read vmbx number from 6f17 file

            VMBLOGSTRING2( "VMBX: CVmbxPbkStore::SimReadLactiveAlsLine = %I",

                 activeAlsLine );

            iPhoneBook.Read( iStatus, activeAlsLine, numEntries, pbData );

            iAsynType = EVmbxSimEntryRead;

            // Wait for asynchronous call to finish

            SetActive();

            iWait->Start();

            }