/*

* Copyright (c) 2007 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:  A class responsible handling the views

 *

*/

// INCLUDE FILES

#include "ccappheaders.h"

#include <mccappviewpluginbase2.h>

#include "ccappmycardpluginuids.hrh"

#include "ccacmscontactfetcherwrapper.h"

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

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

// CCCAppView::CCCAppView

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

//

CCCAppView::CCCAppView( CCCAAppAppUi& aAppUi )

    : iAppUi ( aAppUi ),

      iViewChangeInProgress ( EFalse )

    {

    CCA_DP( KCCAppLogFile, CCA_L("CCCAppView::CCCAppView"));

    }

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

// CCCAppView::~CCCAppView

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

//

CCCAppView::~CCCAppView()

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppView::~CCCAppView"));

    iPluginUidToBeSynchd.Close();

    if ( iCmsWrapper )

        {

        iCmsWrapper->RemoveObserver( *this );    

        iCmsWrapper->Release();

        }

    iObservers.Reset();

    iObservers.Close();

    delete iPaneHandler; 

    delete iPluginLoader;

    delete iViewResetter;

    delete iDelayedConstructor;

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::~CCCAppView"));

    }

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

// CCCAppView::NewL

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

//

CCCAppView* CCCAppView::NewL( CCCAAppAppUi& aAppUi )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppView::NewL"));

    CCCAppView* self = new( ELeave ) CCCAppView( aAppUi );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::NewL"));

    return self;

	}

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

// CCCAppView::ConstructL

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

//

void CCCAppView::ConstructL()

    {

    //CCA_DP( KCCAppLogFile, CCA_L("->CCCAppView::ConstructL"));

    //CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::ConstructL"));

	} 

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

// CCCAppView::StartView

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

//

TInt CCCAppView::StartView( const TUid aUid )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppView::StartView"));

    TRAPD( err, StartViewL( aUid ))

    CCA_DP( KCCAppLogFile, CCA_L("::StartView - StartViewL returned err: %d"), err );

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::StartView"));

    return err;

    }

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

// CCCAppView::StartViewL

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

//

void CCCAppView::StartViewL( const TUid aUid )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppView::StartViewL"));

    iDelayedStarting = ETrue;

    // At the moment mycard does not need to support tabs, so this is 

    // good enough sollution for launching mycard plugin

    TBool isUidMyCard = ( aUid == 

            TUid::Uid( KCCAMyCardPluginImplmentationUid ) );

	// MyCard does not need CMS session. Initializing CMS for no real use

	// will only waste time in MyCard launching.

    if( !isUidMyCard )

        {

        // 1st start the contact fetching

        iCmsWrapper = CCCAppCmsContactFetcherWrapper::CreateInstanceL( 

             &iAppUi.Parameter(), CCCAppCmsContactFetcherWrapper::EFindContactFromOtherStores );

        iCmsWrapper->AddObserverL( *this );

        }

    //In this version support only contact type data (i.e. group data discarded)

    _LIT8( KCcaOpaqueTag_CNT,           "CNT" );    //Contact    

    _LIT8( KCcaOpaqueTag_MCD,           "MCD" );    //MyCard    

    _LIT8( KCcaPluginTypeMyCard,        "application/x-mycard" );    

    TPtrC8 properties( isUidMyCard ? KCcaOpaqueTag_MCD : KCcaOpaqueTag_CNT);

    TPtrC8 type( KNullDesC8 );

    if( isUidMyCard )

        {

        type.Set( KCcaPluginTypeMyCard );    

        }

    iPluginLoader = CCCAppPluginLoader::NewL( this, properties, type );

    CCA_DP( KCCAppLogFile, CCA_L("::ConstructL - iPluginLoader created"));

    iPaneHandler = CCCAppStatusPaneHandler::NewL( *this );

    CCA_DP( KCCAppLogFile, CCA_L("::ConstructL - iPaneHandler created"));    

    // 2nd start constructing the plugin view with preferred

    // plugin view (if provided)

    TInt pluginToFocus = iPluginLoader->SetPluginInFocus( aUid );

    if(pluginToFocus != KErrNotFound)

        {

        iPluginLoader->SetPluginVisibility(aUid, CCCAppPluginData::EPluginVisible); 

        }

    else

        {

        //Not found, try set the first plugin

        pluginToFocus = 0;

        if(iPluginLoader->PluginAt(pluginToFocus)) 

            {

            iPluginLoader->SetPluginVisibility(

                iPluginLoader->PluginAt(pluginToFocus)->Plugin().Id(), CCCAppPluginData::EPluginVisible);  

            }

        }

    //Start plugin and construct CIdle object to call back to finalise 

    //time consuming construction    

    StartPluginL(pluginToFocus);

    iDelayedConstructor = CIdle::NewL( CActive::EPriorityIdle );

    iDelayedConstructor->Start( TCallBack( ConstructDelayedCallbackL, this) );            

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::StartViewL"));

	} 

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

// CCCAppView::ConstructDelayedCallbackL

//

// Called from CIdle to finish time consuming construction operations

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

//

TInt CCCAppView::ConstructDelayedCallbackL( TAny* aContainer )

    {

    CCCAppView* container = static_cast<CCCAppView*>( aContainer );

    container->DoConstructDelayedL();    

    return 0;

    }    

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

// CCCAppView::DoConstructDelayedL

//

// Perform time consuming construction operations

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

//

void CCCAppView::DoConstructDelayedL()

    {

    if( iDelayState == EDelayedCreateTabs )

        {

        iPaneHandler->CreateTabsL();  

        iDelayedConstructor->Start( TCallBack( ConstructDelayedCallbackL, this) );

        iDelayState=EDelayedCheckVisibilities;

        }

    else if( iDelayState == EDelayedCheckVisibilities )

        {

        CheckOtherPluginVisibilitiesL();

        iDelayedConstructor->Start( TCallBack( ConstructDelayedCallbackL, this) );

        }

    else if( iDelayState == EDelayedCheckVisibilitiesOk )

        {

        TInt tabNbr = 0;

        CCCAppPluginData* currPluginData = iPluginLoader->PluginInFocus();    

        if( currPluginData )

            {

            TUid currentlyVisiblePluginId = currPluginData->Plugin().Id();

            iPluginLoader->PluginVisibility( currentlyVisiblePluginId, tabNbr );

            }

        iPaneHandler->ActivateTab( tabNbr );

        iDelayedConstructor->Start( TCallBack( ConstructDelayedCallbackL, this) );

        iDelayState=EDelayedFinish;

        }    

    else

        {

        delete iDelayedConstructor;

        iDelayedConstructor = NULL;

        iDelayedStarting = EFalse;        

        SynchPluginVisibilityWithTabAfterDelayedStartL();

        }

    }

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

// CCCAppView::CheckOtherPluginVisibilitiesL

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

//

void CCCAppView::CheckOtherPluginVisibilitiesL()

    {

    TBool pluginVisibility(EFalse);

    if(iDelayedPluginVisibilityCheck < iPluginLoader->PluginsCount())

        {

        // prepare plugin parameter 

        CCCAppPluginParameter* pluginParam = CCCAppPluginParameter::NewL( *this );

        CleanupStack::PushL( pluginParam );

        TRAPD(err, pluginVisibility = iPluginLoader->

            PluginAt(iDelayedPluginVisibilityCheck)->Plugin().CheckVisibilityL(*pluginParam));

        CleanupStack::PopAndDestroy( pluginParam );

        if (KErrNone == err)

            {

            if(iPluginLoader->SetPluginVisibility(iPluginLoader->

                PluginAt(iDelayedPluginVisibilityCheck)->Plugin().Id(), pluginVisibility))

                {

                iDelayedVisibilityChanged = ETrue;

                }

            }

        else

            {

            CCA_DP( KCCAppLogFile, CCA_L( 

                "CCCAppStatusPaneHandler::CreateTabsL: Plugin %d visibility check failed."), 

                iDelayedPluginVisibilityCheck);

            //Remove plugin from plugin loader

            TUid pluginUid = iPluginLoader->PluginAt(iDelayedPluginVisibilityCheck)->Plugin().Id();

            CCA_DP( KCCAppLogFile, CCA_L("::visibility check - problem plugin uid: %d"), pluginUid.iUid );

            iPluginLoader->RemovePlugin( pluginUid );

            iDelayedVisibilityChanged = ETrue;

            }        

        }

    else 

        {

        //All checked. Reset if changes requested by plugins

        if(iDelayedVisibilityChanged) 

            {

            iPaneHandler->CreateTabsL();

            }

        iDelayState=EDelayedCheckVisibilitiesOk;

        }

    iDelayedPluginVisibilityCheck++;

    }

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

// CCCAppView::StartPluginL

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

//

void CCCAppView::StartPluginL(TInt aPluginToFocus)

    {

    /* 

     * Activating plugin is done in two TRAP-levels. The lower is activating

     * the plugin and if it fails, takes care of recovering from the

     * situation. The higher level takes care of exiting the application

     * if something leaves while recovering from the plugin activation.

     */

    CCCAppPluginData* pluginDataInFocus = iPluginLoader->PluginInFocus();  

    User::LeaveIfNull(pluginDataInFocus);

    TRAPD( err, ActivatePluginL( *pluginDataInFocus ));

    if ( KErrNone == err )

        {// view started successfully - activate correct tab

        // activate 1st view plugin in case preferred plugin uid not found

        iPaneHandler->ActivateTab( KErrNotFound != aPluginToFocus ? aPluginToFocus : 0  );

        }

    else

        {// problem in plugin activation - try to recover

        CCA_DP( KCCAppLogFile, CCA_L("::StartViewL - problem in plugin activation: err %d"), err );

        RecoverFromBadPluginL();            

        }

    }

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

// CCCAppView::ChangeView

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

//

TInt CCCAppView::ChangeView( TBool aForward )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppView::ChangeView"));

    TInt err = KErrNone;

    //Forward the call to statusPane only if it is ready

    if ( iPaneHandler )

        {

        if ( iPaneHandler->IsTabAvailable() )

            {

            TRAP( err, ChangeViewL( aForward ));

            CCA_DP( KCCAppLogFile, CCA_L("::ChangeView - ChangeViewL returned err: %d"), err );

            }

        }   

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::ChangeView"));

    return err;

    }

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

// CCCAppView::ChangeViewL

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

//

void CCCAppView::ChangeViewL( TBool aForward )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppView::ChangeViewL"));

    const TInt visiblePluginCount = iPluginLoader->VisiblePluginCount();  

    if ( KCCAppMinPluginCountForTabs > visiblePluginCount // if only 1 plugin, we can stop handling here

        || iViewChangeInProgress ) // OR view change is in progress

        return;    

    __ASSERT_DEBUG ( iPaneHandler->TabCount() == visiblePluginCount, CCAppPanic( ECCAppPanicObjectCountMismatch ));

    iViewChangeInProgress = ETrue;    

    /* 

     * If ActivateTabL changes tab succesfully, it will call TabChangedL,

     * which then again will do activation the plugin.

     *  

     * Activating plugin is done in two TRAP-levels. The lower is activating

     * the plugin and if it fails, takes care of recovering from the

     * situation. The higher level takes care of exiting the application

     * if something leaves while recovering from the plugin activation.

     */

    TRAPD( err, iPaneHandler->ActivateTabL( aForward ));

    if ( KErrNone != err)

        {

        CCA_DP( KCCAppLogFile, CCA_L("::ChangeViewL - problem in plugin activation: err %d"), err );

        RecoverFromBadPluginL();            

        }

    iViewChangeInProgress = EFalse;    

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::ChangeViewL"));

    }

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

// CCCAppView::TabChangedL

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

//

void CCCAppView::TabChangedL( TInt aIndex )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppView::TabChangedL"));

    CCCAppPluginData* pluginDataInFocus = iPluginLoader->VisiblePlugin( aIndex, ETrue );// not owned

    ActivatePluginL( *pluginDataInFocus );

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::TabChangedL"));

    }

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

// CCCAppView::ActivatePluginL

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

//

void CCCAppView::ActivatePluginL( CCCAppPluginData& aPluginDataInFocus )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppView::ActivatePluginL"));

    //PERFORMANCE LOGGING: 6. Plugin activation

    WriteToPerfLog();

    CCCAppViewPluginBase& plugin = aPluginDataInFocus.Plugin();

    if ( !aPluginDataInFocus.IsPluginPrepared() )

        {// 1st activation

        // prepare plugin parameter

        CCCAppPluginParameter* pluginParam = CCCAppPluginParameter::NewL( *this );

        CleanupStack::PushL( pluginParam );

        plugin.PreparePluginViewL( *pluginParam );

        CleanupStack::PopAndDestroy( pluginParam );

        iAppUi.AddViewL( &plugin );// transfers ownership to AppUi -framework

        aPluginDataInFocus.PluginIsPrepared();

        }

    // activate plugin

    iAppUi.ActivateLocalViewL( plugin.Id() );

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::ActivatePluginL"));

    }

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

// CCCAppView::AppUi

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

//

CCCAAppAppUi& CCCAppView::AppUi()

    {

    CCA_DP( KCCAppLogFile, CCA_L("CCCAppView::AppUi"));

    return iAppUi;

    }

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

// CCCAppView::EikonEnv

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

//

CEikonEnv& CCCAppView::EikonEnv()

    {

    CCA_DP( KCCAppLogFile, CCA_L("CCCAppView::AlfEnv"));

    return iAppUi.EikonEnv();

    }

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

// CCCAppView::PluginLoader

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

//    

CCCAppPluginLoader& CCCAppView::PluginLoader()

    {

    CCA_DP( KCCAppLogFile, CCA_L("CCCAppView::PluginLoader"));

    return *iPluginLoader;

    }

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

// CCCAppView::ContactFieldDataObserverNotifyL

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

//  

void CCCAppView::ContactFieldDataObserverNotifyL( 

        MCCAppContactFieldDataObserver::TParameter& aParameter )

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppView::ContactFieldDataObserverNotifyL"));

    // not interested about other notifications

    if ( MCCAppContactFieldDataObserver::TParameter::EContactDataFieldAvailable 

        == aParameter.iType && NULL != aParameter.iContactField )

        {

        ContactFieldFetchedNotifyL( *aParameter.iContactField );

        }

    else if ( MCCAppContactFieldDataObserver::TParameter::EContactDeleted 

            == aParameter.iType )

        {

        // Quick fix for the urgent need

        //

        // To fix this such manner that CCApplication works as normal Avkon

        // applications do, let the leave with leave code KLeaveExit 

        // go up to CActive's RunL and return it also through RunError.

        // Then normal Avkon AppUi functionality AppUi().Exit() will work.

        AppUi().RunAppShutter();

        }

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::ContactFieldDataObserverNotifyL"));

    }

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

// CCCAppView::ContactFieldDataObserverHandleErrorL

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

//  

void CCCAppView::ContactFieldDataObserverHandleErrorL( 

    TInt aState, TInt aError )

    {

    CCA_DP( KCCAppLogFile, CCA_L("CCCAppView::ContactFieldDataObserverHandleErrorL"));

    CCA_DP( KCCAppLogFile, CCA_L("::ContactFieldDataObserverHandleErrorL - aState: %d, aError: %d"), aState, aError );

    // If no contact found, leave here and launching CCA fails

    if ( CCCAppCmsContactFetcherWrapper::EOpeningContact == aState )

    	{

        User::Leave(aError);

    	}

    }

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

// CCCAppView::ContactFieldFetchedNotifyL

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

//    

void CCCAppView::ContactFieldFetchedNotifyL( 

        CCmsContactField& aContactField )

    {

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::ContactFieldFetchedNotifyL"));

    if ( CCmsContactFieldItem::ECmsFullName == aContactField.Type() )

        {// update titlepane with the name

        CCA_DP( KCCAppLogFile, CCA_L("::ContactFieldFetchedNotifyL - changing title"));

        TPtrC newTxt = aContactField.ItemL( 0 ).Data();        

        iAppUi.SetTitleL( newTxt );          

        }    

    CCA_DP( KCCAppLogFile, CCA_L("<-CCCAppView::ContactFieldFetchedNotifyL"));

    }

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

// CCCAppView::RecoverFromBadPluginL

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

//

void CCCAppView::RecoverFromBadPluginL()

    {

    CCA_DP( KCCAppLogFile, CCA_L("->CCCAppView::RecoverFromBadPluginL"));

#ifdef _DEBUG

    CAknInformationNote* informationNote = new ( ELeave ) CAknInformationNote;

    informationNote->ExecuteLD( _L("Problem in plugin! Check logs!"));         

#endif

    //Remove plugin from plugin loader

    TUid pluginUid = iPluginLoader->PluginInFocus()->Plugin().Id();

    CCA_DP( KCCAppLogFile, CCA_L("::RecoverFromBadPluginL - problem plugin uid: %d"), pluginUid.iUid );

    iPluginLoader->RemovePlugin( pluginUid );

    if ( iPluginLoader->PluginsCount() )

        {// Plugins available

        CCA_DP( KCCAppLogFile, CCA_L("::RecoverFromBadPluginL - plugins found"));