/*

* Copyright (c) 2007-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:  Implementation of comm launcher view plugin

*

*/

#include "ccappcommlauncherheaders.h"

#include <phonebook2ece.mbg>

#include <mccappengine.h>

// Consts

_LIT( KCCAppCommLauncherResourceFileName, "\\resource\\ccappcommlauncherpluginrsc.rsc" );

const TInt KCCAppCommLauncherMaxOrderBufLength = 128;

const TInt KSupportedMethodsArray[] = {

    VPbkFieldTypeSelectorFactory::EVoiceCallSelector,

    VPbkFieldTypeSelectorFactory::EVOIPCallSelector,

    VPbkFieldTypeSelectorFactory::EUniEditorSelector,

    VPbkFieldTypeSelectorFactory::EEmailEditorSelector,

    VPbkFieldTypeSelectorFactory::EInstantMessagingSelector,

    VPbkFieldTypeSelectorFactory::EURLSelector,

    VPbkFieldTypeSelectorFactory::EVideoCallSelector,

    VPbkFieldTypeSelectorFactory::EFindOnMapSelector

    };

const TInt KSupportedMethodsArrayLength = sizeof( KSupportedMethodsArray ) / sizeof( TInt );

const TInt KDelayTime = 30000000; // 30s

/**

 * Panic codes for the class TCCAppCommandState

 */

enum TCCAppCommandStatePanicCode

    {

    ETCCAppCommandState_SetRunning_PreCond = 1

    };

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

// Panic function for the class TCCAppCommandState

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

//

void Panic(TCCAppCommandStatePanicCode aPanicCode)

    {

    _LIT( KPanicText, "TCCAppCommandState" );

    User::Panic( KPanicText, aPanicCode );

    }

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

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

// TCCAppCommandState::TCCAppCommandState

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

//

TCCAppCommandState::TCCAppCommandState()

    : iState( EFalse )

    {

    }

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

// TCCAppCommandState::SetRunning

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

//

void TCCAppCommandState::SetRunning()

    {

    // Catch all the implementation errors in release build too.

    __ASSERT_ALWAYS( !IsRunning(), 

            Panic( ETCCAppCommandState_SetRunning_PreCond ) );

    iState = ETrue;

    }

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

// TCCAppCommandState::SetNotRunning

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

//

void TCCAppCommandState::SetNotRunning()

    {

    iState = EFalse;

    }

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

// TCCAppCommandState::SetRunningAndPushCleanupL

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

//

void TCCAppCommandState::SetRunningAndPushCleanupL()

    {

    SetRunning();

    PushCleanupL();

    }

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

// TCCAppCommandState::SetNotRunningAndPopCleanup

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

//

void TCCAppCommandState::SetNotRunningAndPopCleanup()

    {

    SetNotRunning();

    PopCleanup();

    }

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

// TCCAppCommandState::PushCleanupL

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

//

void TCCAppCommandState::PushCleanupL()

    {

    CleanupStack::PushL( TCleanupItem( TCCAppCommandState::CleanupOperation, 

            this) );

    }

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

// TCCAppCommandState::PopCleanup

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

//

void TCCAppCommandState::PopCleanup()

    {

    CleanupStack::Pop();

    }

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

// TCCAppCommandState::CleanupOperation

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

//

void TCCAppCommandState::CleanupOperation( TAny* aCommanState )

    {

    TCCAppCommandState* state = static_cast<TCCAppCommandState*>( 

            aCommanState );

    state->SetNotRunning();

    }

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

// CCCAppCommLauncherPlugin::NewL

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

//

CCCAppCommLauncherPlugin* CCCAppCommLauncherPlugin::NewL()

    {

    CCA_DP(KCommLauncherLogFile, CCA_L("->CCCAppCommLauncherPlugin::NewL()"));

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    CCA_DP(KCommLauncherLogFile, CCA_L("<-CCCAppCommLauncherPlugin::NewL()"));

    return self;

    }

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

// CCCAppCommLauncherPlugin::~CCCAppCommLauncherPlugin

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

//

CCCAppCommLauncherPlugin::~CCCAppCommLauncherPlugin()

    {

    CCA_DP(KCommLauncherLogFile, CCA_L("->CCCAppCommLauncherPlugin::~CCCAppCommLauncherPlugin()"));

    iPreferredCommMethods.Close();

    if (AppEngine())

        {

        AppEngine()->RemoveObserver(*this);

        }

    delete iMenuHandler;

    delete iContactHandler;

    delete iContactorService;

    delete iAiwRequestTimer;

    CCA_DP(KCommLauncherLogFile, CCA_L("<-CCCAppCommLauncherPlugin::~CCCAppCommLauncherPlugin()"));

    }

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

// CCCAppCommLauncherPlugin::CCCAppCommLauncherPlugin()

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

//

CCCAppCommLauncherPlugin::CCCAppCommLauncherPlugin() : iIsCcaForeground( ETrue ),

        iIsTimerStart( EFalse )

    {

    CCA_DP(KCommLauncherLogFile, CCA_L("CCCAppCommLauncherPlugin()"));

    }

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

// CCCAppCommLauncherPlugin::ConstructL

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

//

void CCCAppCommLauncherPlugin::ConstructL()

    {

    CCA_DP(KCommLauncherLogFile, CCA_L("ConstructL()"));

    // ConstructL should be as light as possible.

    }

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

// CCCAppCommLauncherPlugin::PreparePluginViewL

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

//

void CCCAppCommLauncherPlugin::PreparePluginViewL(

    MCCAppPluginParameter& /*aPluginParameter*/ )

    {

    CCA_DP(KCommLauncherLogFile, CCA_L("->CCCAppCommLauncherPlugin::PreparePluginViewL()"));

    // This plugin has no usage for the aPluginParameter

    if (AppEngine())

        {

        AppEngine()->AddObserverL(*this);

        }

    //PERFORMANCE LOGGING: 7. Preparing plugin

    WriteToPerfLog();

    PrepareViewResourcesL();

    InitialisePreferredCommMethods();

    BaseConstructL( R_COMMLAUNCHER_VIEW );

    CCA_DP(KCommLauncherLogFile, CCA_L("<-CCCAppCommLauncherPlugin::PreparePluginViewL()"));

    }

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

// CCCAppCommLauncherPlugin::DoActivateL

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

//

void CCCAppCommLauncherPlugin::DoActivateL(

    const TVwsViewId& aPrevViewId,

    TUid aCustomMessageId,

    const TDesC8& aCustomMessage )

    {

    CCA_DP(KCommLauncherLogFile, CCA_L("->CCCAppCommLauncherPlugin::DoActivateL()"));

    //PERFORMANCE LOGGING: 8. Activating view

    WriteToPerfLog();

    AppUi()->SetKeyEventFlags(

        CAknAppUiBase::EDisableSendKeyShort |

        CAknAppUiBase::EDisableSendKeyLong );

    // Forward the activation-call to base-class

    CCCAppViewPluginAknView::DoActivateL(

        aPrevViewId, aCustomMessageId, aCustomMessage );

    CCA_DP(KCommLauncherLogFile, CCA_L("::DoActivateL() - create iContactHandler"));

    iContactHandler = CCCAppCommLauncherContactHandler::NewL(

        *static_cast<CCCAppCommLauncherContainer*>(iContainer),

        *this);

    CCA_DP(KCommLauncherLogFile, CCA_L("::DoActivateL() - request contact data"));

    if (iRefetchContact)

    	{

        iContactHandler->RefetchContactL();

        iRefetchContact = EFalse;

      	}

    else

    	{

        iContactHandler->RequestContactDataL();

    	}

    if (!iContactorService)

        {

        iContactorService = CCAContactorService::NewL();

        }

    CCA_DP(KCommLauncherLogFile, CCA_L("<-CCCAppCommLauncherPlugin::DoActivateL()"));

    }

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

// CCCAppCommLauncherPlugin::DoDeactivate

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

//

void CCCAppCommLauncherPlugin::DoDeactivate()

    {

    CCA_DP(KCommLauncherLogFile, CCA_L("->CCCAppCommLauncherPlugin::DoDeactivate()"));

    delete iContactHandler;

    iContactHandler = NULL;

    AppUi()->SetKeyEventFlags( 0 );

    // Forward the deactivation-call to base-class

    CCCAppViewPluginAknView::DoDeactivate();

    // if plugin is showing notifications, this is good place to disable those

    // until ActivatePluginViewL is called again

    // After commlauncher view is deactivated, cancel the timer which started when requests

    // a call services.

    CancelTimer();

    CCA_DP(KCommLauncherLogFile, CCA_L("<-CCCAppCommLauncherPlugin::DoDeactivate()"));

    }

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

// CCCAppCommLauncherPlugin::InitialisePreferredCommMethods

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

//

void CCCAppCommLauncherPlugin::InitialisePreferredCommMethods()

    {

    CCA_DP(KCommLauncherLogFile, CCA_L("->CCCAppCommLauncherPlugin::InitialisePreferredCommMethods()"));

    TRAPD( err, LoadPreferredCommMethodsL() );

    if ( err )

        {// something went wrong with loading from cenrep,

        //  use the default order

#ifdef _DEBUG

        CCA_DP(KCommLauncherLogFile, CCA_L("::InitialisePreferredCommMethods - Comm method variation error."));

        CCA_DP(KCommLauncherLogFile, CCA_L("::InitialisePreferredCommMethods - err: %d"), err );

        CEikonEnv::Static()->InfoMsg(_L("Comm method variation error. See logs."));

#endif//_DEBUG

        iPreferredCommMethods.Reset();

        for ( TInt idx = 0; idx < KSupportedMethodsArrayLength; idx++ )

            {

            iPreferredCommMethods.Append(

                (VPbkFieldTypeSelectorFactory::TVPbkContactActionTypeSelector)

                KSupportedMethodsArray[ idx ]);

            }

        }

    CCA_DP(KCommLauncherLogFile, CCA_L("<-CCCAppCommLauncherPlugin::InitialisePreferredCommMethods()"));

    }

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

// CCCAppCommLauncherPlugin::LoadPreferredCommMethodsL

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

//

void CCCAppCommLauncherPlugin::LoadPreferredCommMethodsL()

    {

    CCA_DP(KCommLauncherLogFile, CCA_L("->CCCAppCommLauncherPlugin::LoadPreferredCommMethodsL()"));

    CRepository* repository = CRepository::NewLC( KCRUidCCACommLauncher );

    TBuf<KCCAppCommLauncherMaxOrderBufLength> orderBuf;

    TInt error = repository->Get( KCommunicationMethodOrder, orderBuf );

    CleanupStack::PopAndDestroy( repository );

    TLex orderLex( orderBuf );

    TPtrC numToken;

    TLex numLex;

    TInt commMethodType;

    const TInt bufLength = orderBuf.Length() - 1;

    while ( orderLex.Offset() < bufLength )

        {

        numToken.Set( orderLex.NextToken() );

        numLex.Assign( numToken );

        // if defined value is string instead of a number,

        // use the default array

        User::LeaveIfError( numLex.Val( commMethodType ));

        CCA_DP(KCommLauncherLogFile, CCA_L("::LoadPreferredCommMethodsL - found commMethodType: %d"), commMethodType );

        // if defined value is outside of the possible comm method

        // values, use the default array

        TBool knownMethod(EFalse);

        for( TInt idx = 0; idx < KSupportedMethodsArrayLength; idx++ )

            {

            if( KSupportedMethodsArray[ idx ] == commMethodType )

                {

                knownMethod = ETrue;

                break;

                }

            }

        if(!knownMethod)

            {

            CCA_DP(KCommLauncherLogFile, CCA_L("::LoadPreferredCommMethodsL - skippin unsupported method(s): %d"),

                    commMethodType );

            User::Leave( KErrArgument );

            }

        iPreferredCommMethods.Append(

            VPbkFieldTypeSelectorFactory::CreateActionTypeSelectorIdL(

                commMethodType ) );

        }

    // if no comm methods defined, use the default array

    User::LeaveIfError( iPreferredCommMethods.Count() ? 0 : KErrNotFound );

    CCA_DP(KCommLauncherLogFile, CCA_L("<-CCCAppCommLauncherPlugin::LoadPreferredCommMethodsL()"));

    }

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

// CCCAppCommLauncherPlugin::ProvideBitmapL

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

//

void CCCAppCommLauncherPlugin::ProvideBitmapL(

    TCCAppIconType aIconType,

    CAknIcon& aIcon )

    {

    CCA_DP(KCommLauncherLogFile, CCA_L("->CCCAppCommLauncherPlugin::ProvideBitmapL()"));

    if ( ECCAppTabIcon == aIconType )

        {

        CFbsBitmap* bmp = NULL;

        CFbsBitmap* bmpMask = NULL;

        AknsUtils::CreateIconL(

            AknsUtils::SkinInstance(),

            KAknsIIDQgnPropPbCommTab3,

            bmp,

            bmpMask,

            KPbk2ECEIconFileName,

            EMbmPhonebook2eceQgn_prop_pb_comm_tab3,

            EMbmPhonebook2eceQgn_prop_pb_comm_tab3_mask );

        aIcon.SetBitmap( bmp );

        aIcon.SetMask( bmpMask );

        }

    CCA_DP(KCommLauncherLogFile, CCA_L("<-CCCAppCommLauncherPlugin::ProvideBitmapL()"));

    }

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

// CCCAppCommLauncherPlugin::CCCAppViewPluginBaseExtension

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

//

TAny* CCCAppCommLauncherPlugin::CCCAppViewPluginBaseExtension( TUid aExtensionUid )

    {

    if ( aExtensionUid == KMCCAppViewPluginBaseExtension2Uid )

        {

        return static_cast<MCCAppViewPluginBase2*>( this );

        }

    return NULL;

    }

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

// CCCAppCommLauncherPlugin::DynInitMenuPaneL

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

//

void CCCAppCommLauncherPlugin::DynInitMenuPaneL(

    TInt aResourceId,

    CEikMenuPane* aMenuPane )

    {

    EnsureMenuHandlerCreatedL();

    iMenuHandler->DynInitMenuPaneL( aResourceId, aMenuPane );

    }

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

// CCCAppCommLauncherPlugin::EnsureMenuHandlerCreatedL

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

//

void CCCAppCommLauncherPlugin::EnsureMenuHandlerCreatedL()

    {

    if ( !iMenuHandler )

        {

        iMenuHandler = CCCAppCommLauncherMenuHandler::NewL( *this );

        iMenuHandler->SetContactStore( iContactHandler->ContactStore() );

        }

    }

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

// CCCAppCommLauncherPlugin::CloseCCApp

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

//

void CCCAppCommLauncherPlugin::CloseCCApp()

    {

    // Cancel timer after timer triggered to make sure the same timer just be 

    // triggered once.

    CancelTimer();

    // If CCA is at background, close CCA application.

    if ( !iIsCcaForeground )

        {

        RWsSession& wsSession = CCoeEnv::Static()->WsSession();

        TApaTask ccapp( wsSession );

        TInt wgId = CCoeEnv::Static()->RootWin().WindowGroupId();

        ccapp.SetWgId( wgId );

        ccapp.EndTask();

        }

    }

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

// CCCAppCommLauncherContainer::ContactorService

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

//

const CCAContactorService* CCCAppCommLauncherPlugin::ContactorService()

    {

    return iContactorService;

    }

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

// CCCAppCommLauncherPlugin::ExecuteServiceL

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

//

void CCCAppCommLauncherPlugin::ExecuteServiceL(

        const CCAContactorService::TCSParameter& aParameter)

    {

    if (iContactorService)

        {

        iCommandState.SetRunningAndPushCleanupL();

        iContactorService->ExecuteServiceL( aParameter );

        iCommandState.SetNotRunningAndPopCleanup();

        }

    }

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

// CCCAppCommLauncherPlugin::StartTimerL

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

//

void CCCAppCommLauncherPlugin::StartTimerL()

    {

    if ( !iAiwRequestTimer )

        {

        iAiwRequestTimer = CPeriodic::NewL( CActive::EPriorityStandard );

        }

    // Cancel the timer before start it to make sure formal timer can be canceled

    // when start a new timer.

    CancelTimer();

    TCallBack callback( ServiceTimeOutL, this );

    iAiwRequestTimer->Start( KDelayTime, KDelayTime, callback );

    iIsTimerStart = ETrue;

    }

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

// CCCAppCommLauncherPlugin::CancelTimer

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

//

void CCCAppCommLauncherPlugin::CancelTimer()

    {

    if ( iAiwRequestTimer && iIsTimerStart )