/*

* Copyright (c) 2002 - 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: Container for Voice mailbox application.

*

*/

// INCLUDE FILES

#include <aknlists.h>

#include <AknDef.h>

#include <AknsUtils.h>

#include <AknsConstants.h>

#include <AknsUtils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <badesca.h>

#include <aknkeys.h>

#include <gulicon.h>

#include <featmgr.h>

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

#include <PbkFields.hrh>

#include <PhCltUtils.h>

#include <AiwServiceHandler.h> //For Application InterWorking

#include <NumberGrouping.h>

#include <NumberGroupingCRKeys.h>

#include <settingsinternalcrkeys.h>

#include <NetworkHandlingDomainPSKeys.h>

#include <centralrepository.h>

#include <AiwDialDataTypes.h>

#include <aiwdialdataext.h>

#include <spsettings.h>

#include <vmnumber.h>

#include <vm.rsg>

#include <vm.mbg>

#include "vm.hrh"

#include "VoiceMailboxAppPrivateCRKeys.h"

#include "voicemailboxdomaincrkeys.h"

#include "VMBLogger.h"

#include "VmContainer.h"

#include "VmApp.h"

#include "VmAppUi.h"

// CONSTANTS

_LIT( KVmNoIconPrefix, "0\t");       // no icon

_LIT( KVmSimIconPrefix, "1\t");      // CS icon, number is stored in sim

_LIT( KVmwCSIconPrefix, "2\t");      // CS icon, number is stored in phone memory

_LIT( KVmwVideoIconPrefix, "3\t");   // default icon to Video

_LIT( KVmwVoIPIconPrefix,  "4\t");   // default icon to VoIP

_LIT( KVmSuffix, "\t");

//for the mbm file

_LIT( KVmMbmDrive, "Z:");

_LIT( KVmLibMbmFile, "vm.mbm");

const TInt KVmClearIcon = 0x02;

const TInt KVmMailboxNumber = 0x04;

const TInt KVmMessageDetails = 0x08;

const TInt KVmPrefixLength = 3;

const TInt KVmIconArraySize = 2;

const TInt KFormattedCharLength = 3;

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

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

// CVmContainer::CVmContainer

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

// might leave.

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

//

CVmContainer::CVmContainer()

    : iArray( 2 ),

      iVmUiOpts( 0 )

    {

    }

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

// CVmContainer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

/*****************************************************

*      Series 60 Customer / ETel

*      Series 60  ETel API

*****************************************************/

void CVmContainer::ConstructL( const TRect& aRect,

                                           CAiwServiceHandler* aServiceHandler )

    {

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

    CreateWindowL();

    SetBlank();

    iServiceProviderSettings = CSPSettings::NewL();

    //Create repository and notify handlers.

    iSession = CRepository::NewL( KCRUidVoiceMailbox );

    iNotifyHandler1 = CCenRepNotifyHandler::NewL( *this, *iSession,

                          CCenRepNotifyHandler::EIntKey, KVmMessageCounter );

    iNotifyHandler2 = CCenRepNotifyHandler::NewL( *this, *iSession,

                          CCenRepNotifyHandler::EIntKey, KVmSummaryInfoIsSet );

    iNotifyHandler3 = CCenRepNotifyHandler::NewL( *this, *iSession,

                          CCenRepNotifyHandler::EIntKey, KVideoMbxSupport );

    iNotifyHandler1->StartListeningL();

    iNotifyHandler2->StartListeningL();

    iNotifyHandler3->StartListeningL();

    FeatureManager::InitializeLibL();

    iFeatureManagerInitialized = ETrue;

    TInt result( KErrNone );

    if ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) )

        {

        result = iSession->Get( KVmUIOpts, iVmUiOpts );

        if ( result != KErrNone )

            {

            if ( result == KErrNotFound )

                {

                iVmUiOpts = 0;

                }

            else

                {

                VMBLOGSTRING2( "VMBX: CVmContainer::ConstructL: CenRep error: %d", result );

                User::Leave( result );

                }

            }

        }

    result = iSession->Get( KVideoMbxSupport, iIsVideoSupported );

    if ( result != KErrNone )

        {

        iIsVideoSupported = EFalse;

        }

    // connect to phoneclient

    iServiceHandler  = aServiceHandler;

    // open vmbx number interface

    User::LeaveIfError( iVmbxNumber.Open() );

    // get the vmbx number of the active ALS line

    TInt ret( iVmbxNumber.GetVmbxNumber( iNumber ) );

    if ( ret != KErrNone && ret != KErrNotFound )

        {

        User::Leave( ret );

        }

    if ( IsVideoSupported() )

        {

        // get the video mailbox number of the active ALS line

        ret = iVmbxNumber.GetVideoMbxNumber( iVideoNumber );

        if ( ret != KErrNone && ret != KErrNotFound )

             {

             User::Leave( ret );

             }

        }

    TInt pngErr( KErrNone );

    TInt pngSupported( 0 );

    CRepository* repository = CRepository::NewL( KCRUidNumberGrouping );

    pngErr = repository->Get( KNumberGrouping, pngSupported );

    delete repository;

    if ( KErrNone == pngErr && pngSupported != 0 )

        {

        iNumberGrouping = CPNGNumberGrouping::NewL( KVmbxMaxNumberLength );

        }

    // construct the listbox object

    iListBox = new (ELeave) CAknDoubleGraphicStyleListBox;

    iListBox->SetContainerWindowL( *this );

    if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )

        {

        iListBox->ConstructL( this, EAknListBoxMultiselectionList );

        }

    else

        {

        iListBox->ConstructL( this, EAknListBoxSelectionList );

        }

    // load the two localised strings for the listbox

    if (  FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) )

        {

        iLine1 = StringLoader::LoadL( R_MAILBOX_NUMBER );

        }

    else

        {

        iLine1 = iEikonEnv->AllocReadResourceL( R_CALL_VOICEMAIL );

        }

    iLine2 = iEikonEnv->AllocReadResourceL( R_NUMBER_PANE_EMPTY );

    if ( FeatureManager::FeatureSupported( KFeatureIdCsVideoTelephony ) )

        {

        iVideoLine1 = iEikonEnv->AllocReadResourceL( R_CALL_VIDEOMAIL );

        iVideoLine2 = iEikonEnv->AllocReadResourceL( R_NUMBER_PANE_EMPTY );

        }

    if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )

        {

        iLine3 = iEikonEnv->AllocReadResourceL( R_INT_CALL_VOICEMAIL );

        iLine4 = iEikonEnv->AllocReadResourceL( R_ADDRESS_PANE_EMPTY );

        }

    FillIndArray();

    // Set the text in the listbox

    // First create space for the items

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

        {

        iArray.AppendL( KNullDesC );

        }

    //construct the list icon array, empty icon and sim icon

    ConstructIconsForListboxL();

    //set the icon array to the list box

    iListBox->ItemDrawer()->FormattedCellData()->SetIconArrayL( iListIcons );

    iListBox->SetListBoxObserver( this );

    // New voice messages

    UpdateNewVoiceMessagesInListBoxL();

    // Voice mailbox number

    UpdateVmbxNumberInListBoxL();

    // Details

    UpdateLastMessageDetailsInListBoxL();

    iListBox->Model()->SetItemTextArray( &iArray );

    iListBox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );

    iListBox->ItemDrawer()->FormattedCellData()->EnableMarqueeL( ETrue );

    iListBox->CreateScrollBarFrameL( ETrue );

    iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(

                        CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    TRect rect( 0, 0, 0, 0 );

    // Temporary rect is passed. Correct rect is set in SizeChanged.

    iSkinContext = CAknsBasicBackgroundControlContext::NewL(

        KAknsIIDQsnBgAreaMainCalc, rect, EFalse );

    SetRect( aRect );

    ActivateL();

    DrawNow();

    // request notify on ALS line changes

    iVmbxNumber.NotifyAlsLineChangeL( this );

    // request notify on vmbx number changes

    iVmbxNumber.NotifyVmbxNumberChangeL( this, ETrue );

    // request notify on Service changes

    iVmbxNumber.NotifyServiceChange( this );

    UpdateData( EFalse );

    iIsCallOngoing = EFalse;

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

    }

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

// CVmContainer::~CVmContainer

// Destructor

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

//

CVmContainer::~CVmContainer()

    {

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

    delete iServiceProviderSettings;

    delete iListBox;

    iArray.Reset();

    delete iLine1;

    delete iLine2;

    delete iVideoLine1;

    delete iVideoLine2;

    delete iLine3;

    delete iLine4;

    iVmbxNumber.NotifyServiceChangeCancel();

    iVmbxNumber.Close();

    if ( iNotifyHandler1 )

        {

        iNotifyHandler1->StopListening();

        delete iNotifyHandler1;

        }

    if ( iNotifyHandler2 )

        {

        iNotifyHandler2->StopListening();

        delete iNotifyHandler2;

        }

    if ( iNotifyHandler3 )

        {

        iNotifyHandler3->StopListening();

        delete iNotifyHandler3;

        }

    delete iSession;

    delete iNumberGrouping;

    iIndArray.Close();

    if ( iFeatureManagerInitialized )

        {

        FeatureManager::UnInitializeLib();

        }

    delete iSkinContext;

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

    }

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

// CVmContainer::SizeChanged

// Called by framework when the view size is changed

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

//

void CVmContainer::SizeChanged()

    {

    if ( iSkinContext )

        {

        iSkinContext->SetRect( TRect( TPoint( 0, 0 ), Rect().Size() ) );

        }

    AknLayoutUtils::LayoutControl( iListBox, Rect(),

                                        AKN_LAYOUT_WINDOW_list_gen_pane( 0 ) );

    }

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

// CVmContainer::CountComponentControls

// Gets a count of the component controls

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

//

TInt CVmContainer::CountComponentControls() const

    {

    if( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )

        {

        return 2; // the listbox is the only control

        }

    else

        {

        return 1; // the listbox is the only control

        }

    }

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

// CVmContainer::ComponentControl

// Gets an indexed component of a compound control

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

//

CCoeControl* CVmContainer::ComponentControl( TInt /*aIndex*/ ) const

    {

    return iListBox;

    }

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

// CVmContainer::AllowedToChangeTheNumber

// Check wether is possible to edit the voice mailbox number.

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

//

TBool CVmContainer::AllowedToChangeTheNumber()

    {

    VMBLOGSTRING( "VMBX: CVmContainer::AllowedToChangeTheNumber: =>" );

    VMBLOGSTRING( "VMBX: CVmContainer::AllowedToChangeTheNumber: <=" );

    return iVmbxNumber.AllowedToChangeTheNumber();

    }

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

// CVmContainer::OfferKeyEventL

// Handles key events

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

//

TKeyResponse CVmContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                                             TEventCode aType )

    {

    VMBLOGSTRING( "VMBX: CVmContainer::OfferKeyEventL: =>" );

    // For CDMA:

    if ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) )

        {

        if ( aType == EEventKey )

            {

            TInt currentItem = CurrentItem();

            if ( currentItem != KErrNotFound )

                {

                if ( aKeyEvent.iCode == EKeyPhoneSend )

                    {

                    if ( currentItem == EVmbxVoiceMessageAmountInd

                                 || currentItem == EVmbxVoiceMailboxNumberInd )

                        {

                        CallVoiceMailBoxL();

                        VMBLOGSTRING( "VMBX: CVmContainer::OfferKeyEventL: Send key" );

                        return EKeyWasConsumed;

                        }

                    }

                if ( aKeyEvent.iCode == EKeyOK )

                    {

                    if ( currentItem == EVmbxVoiceMessageAmountInd )

                        {

                        CallVoiceMailBoxL();

                        VMBLOGSTRING( "VMBX: CVmContainer::OfferKeyEventL: OK key" );

                        return EKeyWasConsumed;

                        }

                    else if ( currentItem == EVmbxVoiceMailboxNumberInd )

                        {

                        if ( AllowedToChangeTheNumber() )

                            {

                            iAvkonAppUi->HandleCommandL( EvmCmdChangeNumber );

                            }

                        else

                            {

                            CallVoiceMailBoxL();

                            }

                        VMBLOGSTRING( "VMBX: CVmContainer::OfferKeyEventL: OK key" );

                        return EKeyWasConsumed;

                        }

                    else if ( currentItem == EVmbxIntCallVoiceMailboxNumberInd &&

                              FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )

                        {

                        VMBLOGSTRING( "VMBX: CVmContainer::OfferKeyEventL: OK key" );

                        return EKeyWasConsumed;

                        }

                    else if ( currentItem == EVmbxDetailsOfLastMessageInd )

                        {

                        iAvkonAppUi->HandleCommandL( EvmCmdShowLastMessageDetails );

                        VMBLOGSTRING( "VMBX: CVmContainer::OfferKeyEventL: OK key" );

                        return EKeyWasConsumed;

                        }

                    }

                }

            }

        return iListBox->OfferKeyEventL( aKeyEvent, aType );

        }

    // General variant:

    if ( aType == EEventKey )

        {

        TInt currentItem = CurrentItem();

        // pressing selection/SEND/enter key initiates a voice call

        if ( ( aKeyEvent.iCode == EKeyOK

               || aKeyEvent.iCode == EKeyPhoneSend

               || aKeyEvent.iCode == EKeyEnter )

            && ( currentItem == EVmbxVoiceMessageAmountInd

                 || currentItem == EVmbxVoiceMailboxNumberInd ) )

            {

            CallVoiceMailBoxL();

            }

        else if ( ( aKeyEvent.iCode == EKeyOK

                    || aKeyEvent.iCode == EKeyPhoneSend

                    || aKeyEvent.iCode == EKeyEnter )

                && ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip )

                && currentItem != EVmbxVoiceMessageAmountInd

                && currentItem != EVmbxVoiceMailboxNumberInd

                && currentItem != EVmbxVideoMailboxNumberInd) )

            {

            CallIntVoiceMailBoxL();

            }

        else if ( IsVideoSupported()

                  && ( aKeyEvent.iCode == EKeyOK

                      || aKeyEvent.iCode == EKeyPhoneSend

                      || aKeyEvent.iCode == EKeyEnter )

                  && currentItem == EVmbxVideoMailboxNumberInd )

            {

            CallVideoMailBoxL();

            }

        if ( ( aKeyEvent.iCode == EKeyUpArrow || aKeyEvent.iCode == EKeyDownArrow ) &&

             ( IsVideoSupported() ||

               FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) )

            {

            TKeyResponse response( iListBox->OfferKeyEventL( aKeyEvent,

                                                                    aType ) );

            iListBox->SetCurrentItemIndex( iListBox->CurrentItemIndex() );

            ( static_cast <CVmAppUi*>iAvkonAppUi ) ->DrawCbaButtonsL();

            VMBLOGSTRING2( "VMBX: CVmContainer::OfferKeyEventL: \

            response = %I", response );

            return response;

            }

        }

    VMBLOGSTRING( "VMBX: CVmContainer::OfferKeyEventL: <=" );

    return EKeyWasConsumed;

    }

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

// CVmContainer::HandleListBoxEventL

// Handles listbox clicks.

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

//

void CVmContainer::HandleListBoxEventL(

    CEikListBox* /*aListBox*/,

    TListBoxEvent aEventType)

    {

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

    VMBLOGSTRING2( "VMBX: HandleListBoxEventL: aEventType=%d", aEventType );

    switch ( aEventType )

        {

        case EEventItemSingleClicked:

            {

            // at begining,if Querying number, 

            // the key envent should not be response

            if( ELauncherQueryingNumber != 

                    ( static_cast <CVmAppUi*>iAvkonAppUi )->GetAppUiState() )

                {