/*

* Copyright (c) 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:  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"

//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 iAlphaStringFromSIM;

    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 =>" );

    // Open tel server and phone

    iETelConnection = CVmbxETelConnection::NewL();

    iWait = new( ELeave ) CActiveSchedulerWait; 

    TVmbxAlsLineType alsLine = VmbxUtilities::AlsLine();

    // Supported ALS line

    if ( EVmbxAlsLineDefault != alsLine )

        {

        // open 6f17 file

        User::LeaveIfError( OpenVmbxPhonebook() );

        }

    // Not supported ALS line

    else

        {

        // USIM exist

        if ( SimFileExistsAndReadAccess() )

            {

            // Open 6fc7 file

            User::LeaveIfError( OpenMbdnPhonebook() );

            }

        // USIM not exist, open 6f17 file

        else

            {

            VMBLOGSTRING( "VMBX: CVmbxPbkStore::ConstructL: no mbdn file\

                then open 6f17 file" );

            User::LeaveIfError( OpenVmbxPhonebook() );

            }

        }

    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 );

    RMobilePhoneBookStore::TMobilePhoneBookInfoV1 info;

    TInt temp = GetVmbxInfo( info );

    if( KErrNone == temp )

        {

        result = ( info.iCaps &

                RMobilePhoneBookStore::KCapsWriteAccess ? 1 : 0 );

        }

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore:: IsWritable: info.iCaps %I",

                     info.iCaps );

    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();

        // New entry

        result = pbkBuffer->AddNewEntryTag();

        if ( KErrNone == result )

            {

            // Add index

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

            result = pbkBuffer->PutTagAndValue( 

            RMobilePhoneBookStore::ETagPBAdnIndex, (TUint16)activeAlsLine );

            }

        // Add name if it existed on SIM card

        // Type of ETagPBText is TDes16

        if ( KErrNone == result && iAlphaStringFromSIM )

            {

            result = pbkBuffer->PutTagAndValue( 

            RMobilePhoneBookStore::ETagPBText, *iAlphaStringFromSIM );

            // Add number,Type of ETagPBNumber is TDes16

            if ( KErrNone == result )

                {

                TPtrC vmbxNumber( KNullDesC );

                result = aEntry.GetVmbxNumber( vmbxNumber );

                if ( KErrNone == result )

                    {

                    result = pbkBuffer->PutTagAndValue( 

                    RMobilePhoneBookStore::ETagPBNumber, vmbxNumber );

                    }

                }

            }

        if ( KErrNone == result )

            {

            if ( iPhoneBookType == EMBDNPhoneBook )

                {

                RMobilePhone::TMobilePhoneVoicemailIdsV3 mbdnInfo;

                result = GetMbdnInfo( EVmbxAlsLine1, 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, activeAlsLine );

                    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 Phonebook

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

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 && KErrNone == result )

            {

            aInfo.iVoice =  EVmbxAlsLine1;

            }

        }

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

         result );

    return result;

    }

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

// CVmbxPbkStore::OpenMbdnPhonebook

// opening mbdn-type phonebook

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

//   

TInt CVmbxPbkStore::OpenMbdnPhonebook()

    {

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

    // try to open mbdn-type phonebook

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

                                         KETelIccMbdnPhoneBook );

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::OpenMbdnPhonebook :\

        MBDN opening result = %I", result );

    if ( KErrNone == result )

        {

        iPhoneBookType = EMBDNPhoneBook;

        }

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

    return result;

    }

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

// CVmbxPbkStore::OpenVmbxPhonebook

// opening vmbx-type phonebook

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

//

TInt CVmbxPbkStore::OpenVmbxPhonebook()

    {

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

    // try to open vmbx-type phonebook

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

                                                 KETelIccVoiceMailBox );

    if ( KErrNone == result )

        {

        iPhoneBookType = EVMBXPhoneBook;

        }

    VMBLOGSTRING2( "Vmbx phonebook opening result = %I ", result );

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

    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;

    delete iAlphaStringFromSIM;

    iAlphaStringFromSIM = NULL;

    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( !IsActive() && !iWait->IsStarted() )

            {

            result = KErrNone;

            // read vmbx number from 6f17 file

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

            iAsynType = EVmbxSimEntryRead;

            // Wait for asynchronous call to finish

            SetActive();

            iWait->Start();

            }

        }

    User::LeaveIfError( result );

    // asynchronous call finished

    VMBLOGSTRING2( "PhoneBook read iStatus = %I", iStatus.Int() );

    if( iStatus.Int() == KErrNone )

        {

        ParseDataL( aEntry, pbData );

        }

    else

        {

        User::Leave( iStatus.Int() );

        }

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

    }

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

// CVmbxPbkStore::ParseDataL

// read vmbx number from sim

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

//

void CVmbxPbkStore::ParseDataL( CVoiceMailboxEntry& aEntry, TDes8& aPbData )

    {

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

    TInt result( KErrNotFound );

    delete iAlphaStringFromSIM;

    iAlphaStringFromSIM = NULL;

    VMBLOGSTRING2( "CVmbxPbkStore::ParseDataL Lengh = %d", aPbData.Length() );

    if ( aPbData.Length() )

        {

        // -> Search Tags "ETagPBNumber" and "ETagPBText"

        // and read (decode) them

        // create buffer

        CPhoneBookBuffer* pbkBuffer = new( ELeave ) CPhoneBookBuffer();

        CleanupStack::PushL( pbkBuffer );

        // start read

        pbkBuffer->Set( &aPbData );

        pbkBuffer->StartRead();

        result = ReadNewEntryTag( pbkBuffer );

        // Read first "new-entry-tag"

        if ( KErrNone == result )

            {

            ReadPbkDataL( pbkBuffer, aEntry );

            }

        CleanupStack::PopAndDestroy( pbkBuffer );

        }

    VMBLOGSTRING2( "VMBX: CVmbxPbkStore::ParseDataL: result %I", result );

    User::LeaveIfError( result );

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

    }

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

// CVmbxPbkStore::ReadNewEntryTag

// Reads "new-entry-tag" from phonebook data from Sim

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