/*

* 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 CVoiceMailboxImpl class

*

*/

// INCLUDE FILES

#include <featmgr.h>

#include <cvoicemailboxentry.h>

#include "voicemailboxdefsinternal.h"

#include "vmbxenginebase.h"

#include "vmbxuiutilities.h"

#include "vmbxenginefactory.h"

#include "vmbxobserver.h"

#include "vmbxlogger.h"

#include "vmbxutilities.h"

#include "vmbxcenrephandler.h"

#include "voicemailboximpl.h"

// phone application uid

const TInt KPhoneApplicationUid          = 0x100058B3;

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

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

// CVoiceMailboxImpl::NewL

// Two-phased constructor.

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

//

CVoiceMailboxImpl* CVoiceMailboxImpl::NewL()

    {

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

    CVoiceMailboxImpl* vmbx = CVoiceMailboxImpl::NewLC();

    CleanupStack::Pop( vmbx );

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

    return vmbx;

    }

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

// CVoiceMailboxImpl::NewLC

// Two-phased constructor.

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

//

CVoiceMailboxImpl* CVoiceMailboxImpl::NewLC()

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::NewLC =>" );

    CVoiceMailboxImpl* vmbx = new( ELeave ) CVoiceMailboxImpl();

    CleanupStack::PushL( vmbx );

    vmbx->ConstructL();

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::NewLC <=" );

    return vmbx;

    }

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

// CVoiceMailboxImpl::~CVoiceMailboxImpl

// Destructor

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

//

CVoiceMailboxImpl::~CVoiceMailboxImpl()

    {

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

    FeatureManager::UnInitializeLib();

    delete iUiUtilities;

    delete iVmbxFactory;

    delete iVmbxObserver;

    delete iCenRepHandler;

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

    }

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

// CVoiceMailboxImpl::GetStoredEntry

// 

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

//

TInt CVoiceMailboxImpl::GetStoredEntry( const TVoiceMailboxParams& aParams,

                                            CVoiceMailboxEntry*& aEntry ) const

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::GetStoredEntry =>" );

    TRAPD( err, GetStoredEntryL( aParams, aEntry ) );

    VMBLOGSTRING2( "VMBX: CVoiceMailboxImpl::GetStoredEntry: err%I <=", err );

    return err;

    }

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

// CVoiceMailboxImpl::SaveEntry

// 

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

//

TInt CVoiceMailboxImpl::SaveEntry( const CVoiceMailboxEntry& aEntry )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::SaveEntry =>" );

    TRAPD( err, SaveEntryL( aEntry ) );

    VMBLOGSTRING2( "VMBX: CVoiceMailboxImpl::SaveEntry: err%I <=", err );

    return err;

    }

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

// CVoiceMailboxImpl::QueryNewEntry

// 

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

//

TInt CVoiceMailboxImpl::QueryNewEntry( const TVoiceMailboxParams& aParams,

                                           CVoiceMailboxEntry*& aEntry )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::QueryNewEntry =>" );

    TRAPD( err, QueryNewEntryL( aParams, aEntry ) );

    VMBLOGSTRING2( "VMBX: CVoiceMailboxImpl::QueryNewEntry err%I <=",

        err );

    return err;

    }

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

// CVoiceMailboxImpl::QueryChangeEntry

// 

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

//

TInt CVoiceMailboxImpl::QueryChangeEntry( const TVoiceMailboxParams& aParams,

                                             CVoiceMailboxEntry*& aEntry )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::QueryChangeEntry =>" );

    TRAPD( err, QueryChangeEntryL( aParams, aEntry ) );

    VMBLOGSTRING2( "VMBX: CVoiceMailboxImpl::QueryChangeEntry: err%I <=",

        err );

    return err;

    }

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

// CVoiceMailboxImpl::QueryVmbxType

// 

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

//

TInt CVoiceMailboxImpl::QueryVmbxType( TVoiceMailboxParams& aParams )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::QueryVmbxType =>" );

    TRAPD( err, QueryVmbxTypeL( aParams ) );

    VMBLOGSTRING2( "VMBX: CVoiceMailboxImpl::QueryVmbxType: err%I<=", err );

    return err;

    }

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

// CVoiceMailboxImpl::NotifyVmbxNumberChangeL

//

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

//

void CVoiceMailboxImpl::NotifyVmbxNumberChangeL(

    MVoiceMailboxObserver& aObserver,

    const TBool /*aNotifyOnActiveLineOnly*/ )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::NotifyVmbxNumberChangeL =>" );

    if ( !iNotifyCallBack )

        {

        iNotifyCallBack = &aObserver;

        iVmbxObserver = CVmbxObserver::NewL( *this );

        iVmbxObserver->SetVmbxObserver( *this );

        }

    else

        {

        User::Leave( KErrInUse );

        }

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::NotifyVmbxNumberChangeL <=" );

    }

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

// CVoiceMailboxImpl::NotifyVmbxNumberChangeCancel

//

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

//

void CVoiceMailboxImpl::NotifyVmbxNumberChangeCancel()

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::NotifyVmbxNumberChangeCancel =>" );

    iNotifyCallBack = NULL;

    delete iVmbxObserver;

    iVmbxObserver = NULL;

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::NotifyVmbxNumberChangeCancel <=" );

    }

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

// CVoiceMailboxImpl::CheckConfiguration

//

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

//

TBool CVoiceMailboxImpl::CheckConfiguration( const TVoiceMailboxParams& aParams,

                             const TInt aFlags )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::CheckConfiguration =>" );

    TBool configuration( EFalse );

    CVmbxEngineBase* vmbx = NULL;

    TRAPD( res, iVmbxFactory->CreateEngineL( vmbx, aParams.iType ) );

    if ( KErrNone == res && vmbx )

        {

        configuration = vmbx->CheckConfiguration( aParams, aFlags );

        }

    delete vmbx;

    vmbx = NULL;

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::CheckConfiguration <=" );

    return configuration;

    }

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

// CVoiceMailboxImpl::GetServiceIds

//

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

//

TInt CVoiceMailboxImpl::GetServiceIds( RIdArray& aProfileIds )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::GetServiceIds =>" );

    TRAPD( err, GetServiceIdsL( aProfileIds ) );

    VMBLOGSTRING2( "VMBX: CVoiceMailboxImpl::GetServiceIds: err%I <=", err );

    return err;

    }

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

// CVoiceMailboxImpl::GetVmbxImage

//

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

/* CGulIcon* CVoiceMailboxImpl::GetVmbxImage(

                        const TVoiceMailboxParams& aParams )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::GetVmbxImage =>" );

    CGulIcon* guiIcon( NULL );

    TRAPD( err, guiIcon = GetVmbxImageL( aParams ) );

    if ( KErrNone != err )

        {

        delete guiIcon;

        guiIcon = NULL;

        }

    VMBLOGSTRING2( "VMBX: CVoiceMailboxImpl::GetVmbxImage: err%I <=", err );

    return guiIcon;

    } */

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

// CVoiceMailboxImpl::GetVmbxImages

//

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

//

/* CArrayPtr<CGulIcon>* CVoiceMailboxImpl::GetVmbxImages(

                            RArray<TVoiceMailboxParams>& aParams )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::GetVmbxImages =>" );

    CArrayPtr<CGulIcon>* guiIcons( NULL );

    TRAPD( err, guiIcons = GetVmbxImagesL( aParams ) );

    if ( KErrNone != err )

        {

        if ( guiIcons )

            {

            guiIcons->ResetAndDestroy();

            }

        }

    VMBLOGSTRING2( "VMBX: CVoiceMailboxImpl::GetVmbxImages: err%I <=", err );

    return guiIcons;

    } */

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

// CVoiceMailboxImpl::SaveProvisionedEntry

//

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

//

TInt CVoiceMailboxImpl::SaveProvisionedEntry( 

                                    const CVoiceMailboxEntry& aEntry )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::SaveProvisionedEntry =>" );

    TRAPD( err, SaveProvisionedEntryL( aEntry ) );

    VMBLOGSTRING2( "VMBX: CVoiceMailboxImpl::SaveProvisionedEntry: err%I <=",

    err );

    return err;

    }

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

// CVoiceMailboxImpl::SatRefreshL

// 

// notify Sat Refresh

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

//

void CVoiceMailboxImpl::SatRefreshL()

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::SatRefreshL =>" );

    // notify sim file's entry changed

    NotifyChangedL( EVmbxVoice );

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::SatRefreshL <=" );

    }

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

// CVoiceMailboxImpl::CenRepChangedL

// 

// notify CenRep Changed

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

//

void CVoiceMailboxImpl::CenRepChangedL( TVmbxCenRepKey aId )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::CenRepChangedL =>" );

    TVmbxAlsLineType alsLine = VmbxUtilities::AlsLine();

    if ( ( ( EVmbxVoiceLinePrimaryKey == aId 

            || EVmbxVideoLinePrimaryKey == aId ) // primary value changed

            && EVmbxAlsLine2 != alsLine )// line 1 active or using default line

        || ( ( EVmbxVoiceLineAlternateKey == aId 

            || EVmbxVideoLineAlternateKey == aId )// alternate value changed

            && EVmbxAlsLine2 == alsLine ) )// line 2 active

        {

        if ( VmbxUtilities::VideoSupported() 

            && ( ( EVmbxVideoLinePrimaryKey == aId 

            || EVmbxVideoLineAlternateKey == aId ) ) )

            {

            NotifyChangedL( EVmbxVideo );

            }

        else

            {

            NotifyChangedL( EVmbxVoice );

            }

        }

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::CenRepChangedL <=" );

    }

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

// CVoiceMailboxImpl::SimStoreChangedL

// notify sim store changed

// 

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

//

void CVoiceMailboxImpl::SimStoreChangedL()

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::SimStoreChangedL =>" );

    // notify sim file changed

    NotifyChangedL( EVmbxVoice );

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::SimStoreChangedL <=" );

    }

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

// CVoiceMailboxImpl::CVoiceMailboxImpl

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

// might leave.

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

//

CVoiceMailboxImpl::CVoiceMailboxImpl()

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::CVoiceMailboxImpl <=>" );

    }

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

// CVoiceMailboxImpl::ConstructL

// Two-phased constructor.

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

//

void CVoiceMailboxImpl::ConstructL()

    {

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

    FeatureManager::InitializeLibL();

    // Create Ui utilities for dialog and images

    iUiUtilities = CVmbxUiUtilities::NewL();

    // create CenRep

    iCenRepHandler = CVmbxCenRepHandler::NewL();

    // Create factory for voice/video/voip engine

    iVmbxFactory = CVmbxEngineFactory::NewL( *this );

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

    }

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

// CVoiceMailboxImpl::GetStoredEntryL

// 

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

//

void CVoiceMailboxImpl::GetStoredEntryL( const TVoiceMailboxParams& aParams,

                                    CVoiceMailboxEntry*& aEntry ) const

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::GetStoredEntryL =>" );

    CVoiceMailboxEntry* entry( NULL );

    CVmbxEngineBase* vmbxBox( NULL );

    iVmbxFactory->CreateEngineL( vmbxBox, aParams.iType );

    CleanupStack::PushL( vmbxBox );

    vmbxBox->GetL( entry );

    CleanupStack::PopAndDestroy( vmbxBox );

    aEntry = entry;

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::GetStoredEntryL <=" );

    }

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

// CVoiceMailboxImpl::SaveEntryL

// 

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

//

void CVoiceMailboxImpl::SaveEntryL( const CVoiceMailboxEntry& aEntry )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::SaveEntryL =>" );

    TVoiceMailboxParams params( aEntry );

    CVmbxEngineBase* vmbxBox( NULL );

    iVmbxFactory->CreateEngineL( vmbxBox, aEntry.VoiceMailboxType() );

    CleanupStack::PushL( vmbxBox );

    if ( vmbxBox->CheckConfiguration( params, EVmbxChangeNbrAllowedOnUi ) )

        {

        vmbxBox->SaveL( aEntry, ETrue );

        }

    else

        {

        User::Leave( KErrNotSupported );

        }

    CleanupStack::PopAndDestroy( vmbxBox );

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::SaveEntryL <=" );

    }

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

// CVoiceMailboxImpl::QueryNewEntryL

// 

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

//

void CVoiceMailboxImpl::QueryNewEntryL( const TVoiceMailboxParams& aParams,

                                   CVoiceMailboxEntry*& aEntry )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::QueryNewEntryL =>" );

    CVmbxEngineBase* vmbxBox( NULL );

    iVmbxFactory->CreateEngineL( vmbxBox, aParams.iType );

    CleanupStack::PushL( vmbxBox );

    if ( vmbxBox->CheckConfiguration( aParams, EVmbxChangeNbrAllowedOnUi ) )

        {

        CVoiceMailboxEntry* entry = CVoiceMailboxEntry::NewLC();

        entry->SetVoiceMailboxType( aParams.iType );

        entry->SetServiceId( aParams.iServiceId );

        vmbxBox->QueryDefineNumberL( *entry );

        CleanupStack::Pop( entry );

        aEntry = entry;

        }

    else

        {

        CheckNumberProvisionedL( aParams );

        }

    CleanupStack::PopAndDestroy( vmbxBox );

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::QueryNewEntryL <=" );

    }

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

// CVoiceMailboxImpl::QueryChangeEntryL

// 

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

//

void CVoiceMailboxImpl::QueryChangeEntryL( const TVoiceMailboxParams& aParams,

                                            CVoiceMailboxEntry*& aEntry )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::QueryChangeEntryL =>" );

    CVmbxEngineBase* vmbxBox( NULL );

    iVmbxFactory->CreateEngineL( vmbxBox, aParams.iType );

    CleanupStack::PushL( vmbxBox );

    if ( vmbxBox->CheckConfiguration( aParams, EVmbxChangeNbrAllowedOnUi ) )

        {

        CVoiceMailboxEntry* entry( NULL );

        GetStoredEntryL( aParams, entry );

        CleanupStack::PushL( entry );

        vmbxBox->QueryChangeNumberL( *entry );

        CleanupStack::Pop( entry );

        aEntry = entry;

        }

    else

        {

        CheckNumberProvisionedL( aParams );

        }

    CleanupStack::PopAndDestroy( vmbxBox );

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::QueryChangeEntryL <=" );

    }

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

// CleanupRPointerArray

// avoid memory leak when using RPointerArray

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

//

LOCAL_C void CleanupRPointerArray( TAny* aParam )

    {

    if ( aParam )

        {

        static_cast< RPointerArray<CVoiceMailboxEntry>* >( aParam )

                                                    ->ResetAndDestroy();

        }

    }

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

// CVoiceMailboxImpl::QueryVmbxTypeL

// Query vmbx type

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

//

void CVoiceMailboxImpl::QueryVmbxTypeL( TVoiceMailboxParams& aParams )

    {

    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::QueryVmbxTypeL =>" );

    aParams.iType = EVmbxNone;

    aParams.iServiceId = KVmbxServiceIdNone;

    TInt result ( KErrNotFound );

    RPointerArray<CVoiceMailboxEntry> array;

    TCleanupItem item( CleanupRPointerArray, &array );

    CleanupStack::PushL( item );

    GetDefinedEntriesL( array );

    TInt definedCount = array.Count();

    VMBLOGSTRING2( "VMBX: CVoiceMailboxImpl::QueryVmbxTypeL:\

        definedCount%I", definedCount );

    // more than one number defined

    if ( definedCount > 1 )

        {

        VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::QueryVmbxTypeL:\

        more than one number Denfined" );

        // query call type

        RArray<TVoiceMailboxParams> paramsArray;

        CleanupClosePushL( paramsArray );

        TVoiceMailboxParams entryParams;

        for ( TInt i = 0; i < array.Count(); i++ )

            {

            entryParams.iType = array[i]->VoiceMailboxType();

            entryParams.iServiceId = array[i]->ServiceId();

            paramsArray.AppendL( entryParams );

            }

        //CArrayPtr<CGulIcon>* dialogIcons = GetVmbxImagesL( paramsArray );

        //CleanupStack::PushL( dialogIcons );

        iUiUtilities->ShowCallSelectionDialogL( 

        array, /* dialogIcons, */ aParams, result );

        //CleanupStack::Pop( dialogIcons );

        CleanupStack::PopAndDestroy( &paramsArray );

        }

    // only one number defined

    else if ( 1 == definedCount )

        {