/*

* Copyright (c) 2004 - 2008 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 CVtUiAppUi application UI class.

*

*/

// INCLUDE FILES

#include    "videotelui.hrh"

#include    "CVtUiAppUi.h"

#include    "CVtUiMainControl.h"

#include    "CVtUiContextControl.h"

#include    "CVtUiNumberEntryActivationControl.h"

#include    "CVtUiNaviPane.h"

#include    "VtUiLayout.h"

#include    "MVtUiEngineCommandManager.h"

#include    "CVtUiExecuteCmdDialog.h"

#include    "CVtUiAllowVideoDialog.h"

#include    "CVtUiBlankControl.h"

#include    "VtUiLayout.h"

#include    "VtUiUtility.h"

#include    "VtUiPanic.h"

#include    "CVtUiActivateBtHfDialog.h"

#include    "CVtUiRemoteVideoControl.h"

#include    "CVtUiEndCallButtonPane.h"

#include    <csxhelp/incl.hlp.hrh>

#include    <AknIncallBubbleNotify.h>

#include    <AknsLayeredBackgroundControlContext.h>

#include    <AknUtils.h>

#include    <aknnavi.h>

#include    <akntitle.h>

#include    <AknDlgShut.h>

#include    <aknnotedialog.h>

#include    <aknnotewrappers.h>

#include    <akncontext.h>

#include    <eikspane.h>

#include    <eikmenup.h>

#include    <eikmenub.h>

#include    <apgcli.h>

#include    <featmgr.h>

#include    <videotelui.rsg>

#include    <hlplch.h>

#include    <apgwgnam.h>

#include    <StringLoader.h>

#include    <AknDef.h>

#include    <aknconsts.h>

#include    <akntoolbar.h>

#include    <e32property.h>

#include    <ecom/ecom.h>

#include    <coreapplicationuisdomainpskeys.h>

#include    <UikonInternalPSKeys.h>

#include    <centralrepository.h>

#include    <videotelephonyinternalcrkeys.h>

#include    <settingsinternalcrkeys.h>

#include    <e32property.h>

#include    <telcommsinfopskeys.h>

#include    <telinformationpskeys.h>

#include    <activeidle2domainpskeys.h>

#include     <ctsydomainpskeys.h>

#include    <AknQueryDialog.h>

#include     <AknGlobalNote.h>

#include     <aknsoundsystem.h>

#include    <cvtlogger.h>

#include    <cvtengmodel.h>

#include    <mvtengeventobserver.h>

#include    <mvtengcommandobserver.h>

#include    <mvtengcommandhandler.h>

#include    <mvtengframeobserver.h>

#include    <mvtengaudio.h>

#include    <mvtengsessioninfo.h>

#include    <vtengevents.h>

#include    <mvtengmedia.h>

#include    "CVtUiBitmapManager.h"

#include    <MGFetch.h>

#include    <MMGFetchVerifier.h>

#include    <caf/manager.h>

#include    <caf/virtualpathptr.h>

#include    "cvtuifeaturemanager.h"

#include    "cvtuicomponentmanager.h"

#include    "cvtuicommandmanager.h"

#include    "tvtuistates.h"

#include    "cvtuimenus.h"

#include    "cvtuisoftkeys.h"

#include    "cvtuitoolbarbase.h"

#include    "cvtuiwhitebalance.h"

#include    "cvtuicolortone.h"

#include    "cvtuibrightness.h"

#include    "cvtuicontrast.h"

#include    <remconinterfaceselector.h>

#include    <remconcoreapitarget.h>

#include    <remconcoreapitargetobserver.h>

#include    "tvtuiwsevent.h"

#include    "mvtuinumbersource.h"

#include    "tVtuifeaturevariation.h"

#include    "cvtuidialer.h"

#include    "tvtuiappstates.h"

#include    "cvtuivolume.h"

#include    "cvtuizoom.h"

#include    "cvtuivolumecontrol.h"

using namespace ContentAccess;

// CONSTANTS

// Engine orientation to application orientation map

const CVtUiAppUi::TAppUiOrientation engToAppOrientation[] = {

    CVtUiAppUi::EAppUiOrientationLandscape,

    CVtUiAppUi::EAppUiOrientationPortrait,

    CVtUiAppUi::EAppUiOrientationUnspecified };

// Amount of help contexts.

const TInt KVtUiHelpContextAmount = 1;

// UID of Video Telephone application.

const TUid KVtUiAppUid = { KVtUiAppUidValue };

// Granularity of command observer array.

const TInt KVtUiCommandObserverArrayGranularity = 5;

// Default call index.

const TInt KVtUiDefaultCallId = 1;

// Control priority for the blank control. Above all other controls.

const TInt KVtUiBlankControlPriority =

    ECoeStackPriorityEnvironmentFilter + 100;

// Exit timeout.

const TInt KVtUiExitTimeout = 10000000;

// UID of the main telephone application

const TUid KVtUiTelephoneUid = { 0x100058B3 };

// Reset value for volume

const TInt  KVolumeResetValue = -1;

// Remote video control normal priority

const TInt KVtUiRemoteVideoControlOrdinalPriNormal = 0;

// Remote video control high priority

const TInt KVtUiRemoteVideoControlOrdinalPriHigh = 1;

// Name of the EIKON server window group.

_LIT( KVtUiEikonServer, "EikonServer" );

// Name of the AknCapServer window group.

_LIT( KVtUiAknCapServer, "*akncapserver*" );

// Name of the AknNotifierServer window group.

_LIT( KVtUiAknNotifierServer, "*aknnfysrv*" );

// Volume repeat delay.

const TInt KVtUiVolumeRepeatDelay = KAknStandardKeyboardRepeatRate;

// Volume repeat long delay.

const TInt KVtUiVolumeRepeatLongDelay = KAknKeyboardRepeatInitialDelay;

// Start time for toolbar timer

const TTimeIntervalMicroSeconds32 KStartTime( 600000 );

// period time for toolbar timer

const TTimeIntervalMicroSeconds32 KPeriodTime( 300000 );

// The maximum frequency that user can swap image places.

const TInt64 KVtUiMaxSwapImagesFreq( 1000000 );

// Enumerates methods used in event handling. This enumeration MUST

// match with methodArray local array.

enum TVtUiHandleEvents

    {

    // Refresh states

    EVtUiRefreshStates =                    1 << 0,

    // Handle remote problem.

    EVtUiHandleVideoFrameRemoteProblem =    1 << 1,

    // Handle local problem.

    EVtUiHandleVideoFrameLocalProblem =     1 << 2,

    // Refresh navipane.

    EVtUiRefreshNaviPane =                  1 << 3,

    // Refresh softkeys.

    EVtUiRefreshSoftkeys =                  1 << 4,

    // Refresh blind icon status.

    EVtUiRefreshBlind =                     1 << 5,

    // Stop showing waiting image text.

    EVtUiStopWaitingImage =                 1 << 6,    

    // Rx resolution changed.

    EVtUiChangeRemoteVideoLayout =          1 << 7,

    // Show initializing image progress

    EVtUiShowImageInitializingProgress =    1 << 8,

    // Hide initializing image progress

    EVtUiHideImageInitializingProgress =    1 << 9,

    // Set camera orientation

    EVtUiSetOrientation =                   1 << 10,

    //Handle media status change

    EVtUiMediaStateChanged =                1 << 11,

    //Show decoding error note

    EVtUiShowDecodingError =                1 << 12,

    // Stop the white balance and color tone

    EVtUiStopWBOrColortone =                1 << 13,

    // refresh Menu

    EVtUiRefreshMenu =                      1 << 14,

    // Stop brightness and contrast slider

    EVtUiStopBrightnessOrContrast =         1 << 15,

    // refresh zoom popup

    EVtUiRefreshZoomPopup =                           1 << 16

    };

// Enumerates states for CVtUiActiveExec.

enum

    {

    // Operation finished. Must equal to zero.

    EVtUiAppUiNone,

    // Active execution states for iActiveExec:

    // Startup (prepare engine):

    EVtUiAppUiStartup = 100,                             // 100

    //     Close dialogs.

    EVtUiAppUiStartupCloseDialogs = EVtUiAppUiStartup,   // 100

    //     Initialise engine.

    EVtUiAppUiStartupInitEngine,                         // 101

    //     Prepare viewfinder.

    EVtUiAppUiStartupPrepareViewfinder,                  // 102

    //     Prepare remote render.

    EVtUiAppUiStartupPrepareRemoteRender,                // 103

    //     Remove blank.

    EVtUiAppUiStartupRemoveBlank,                        // 104

    // Shutdown (reset engine):

    EVtUiAppUiShutdown = 300,                            // 300

    //     Close dialogs.

    EVtUiAppUiShutdownCloseDialogs = EVtUiAppUiShutdown, // 300

    //     Hide application.

    EVtUiAppUiShutdownHideApplication,                   // 301

    //     Reset engine.

    EVtUiAppUiShutdownResetEngine,                       // 302

    //     Remove blank.

    EVtUiAppUiShutdownRemoveBlank,                       // 303

    // Answered:

    EVtUiAppUiAnswered = 500,                            // 500

    //     Show blank dialog.

    EVtUiAppUiAnsweredStart = EVtUiAppUiAnswered,        // 500

    //     Refresh navipane.

    EVtUiAppUiAnsweredRefreshNavi,                       // 501

    //     Refresh softkeys.

    EVtUiAppUiAnsweredRefreshSoftkeys,                   // 502

    //     Start remote render.

    EVtUiAppUiAnsweredStartRemoteRender,                 // 503

    //     Prepares camera

    EVtUiAppUiAnsweredCheckCamera,                       // 504

    //     Choose if it's needed to show query or directly activate camera.

    EVtUiAppUiAnsweredChoose,                            // 505

    //     Set still image as source.

    EVtUiAppUiAnsweredQuerySetupStill,                   // 506

    //     Set none as source.

    EVtUiAppUiAnsweredQuerySetupNone,                    // 507

    //     Start viewfinder.

    EVtUiAppUiAnsweredQuerySetupStart,                   // 508

    //     Show "allow video image" query.

    EVtUiAppUiAnsweredQueryShow,                         // 509

    //     Check if user allowed video image.

    EVtUiAppUiAnsweredQueryDecide,                       // 510

    //     Select camera as source.

    EVtUiAppUiAnsweredQuerySelectCamera,                 // 511

    //     Select still image as source.

    EVtUiAppUiAnsweredQuerySelectStill,                  // 512

    //     Select none as source.

    EVtUiAppUiAnsweredQuerySelectNone,                   // 513

    //     Start viewfinder.

    EVtUiAppUiAnsweredQueryStartViewfinder,              // 514

    //     Finish.

    EVtUiAppUiAnsweredQueryFinish,                       // 515

    //     Select camera as source.

    EVtUiAppUiAnsweredSelectCamera,                      // 516

    //     Select still image as source.

    EVtUiAppUiAnsweredSelectStill,                       // 517

    //     Select none as source.

    EVtUiAppUiAnsweredSelectNone,                        // 518

    //     Start viewfinder.

    EVtUiAppUiAnsweredStartViewfinder,                   // 519

    //     Finish.

    EVtUiAppUiAnsweredFinish,                            // 520

    //     Prepares camera

    EVtUiAppUiAnsweredDoPrepareCamera                   // 521

    };

/**

* Enumerates background layers

*/

enum TVtUiBackgroundLayers

    {

    // Idle state background.

    EVtUiLayerBackground = 0,

    // Wallpaper layout.

    EVtUiLayerWallpaper = 1,

    // Amount of layers.

    EVtUiLayerCount = 2

    };

// MODULE DATA STRUCTURES

/**

* Asynchronous command executor that does not use dialog for waiting the

* execution completion.

* @since Series 60 5.0

*/

class CVtEngCmdExec : public CBase, private MVtEngCommandObserver

    {

public:

    /**

    * Static constructor.

    */

    static CVtEngCmdExec* NewL( MVtEngCommandHandler& aCommandHandler,

        MVtUiEngineCommandManager& aCommandManager,

        CEikButtonGroupContainer& aCBA );

    /**

    * Executes given command asynchronously, waiting the command completion.

    */

    void ExecuteCmdLD( const TVtEngCommandId aCommandId );

    /**

    * Destructor.

    */

    ~CVtEngCmdExec();

private: // from MVtEngCommandObserver

    /**

    * @see MVtEngCommandObserver::HandleVTCommandPerformedL

    */

    void HandleVTCommandPerformedL( TVtEngCommandId aCommand,

        const TInt aError );

private:

    /**

    * Constructor.

    */

    CVtEngCmdExec( MVtEngCommandHandler& aCommandHandler,

        MVtUiEngineCommandManager& aCommandManager,

        CEikButtonGroupContainer& aCBA );

private:

    CActiveSchedulerWait iWait;

    MVtEngCommandHandler& iCommandHandler;

    MVtUiEngineCommandManager& iCommandManager;

    TVtEngCommandId iCommandId;

    CEikButtonGroupContainer& iCBA;

    };

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

// CVtEngCmdExec::NewL

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

//

CVtEngCmdExec* CVtEngCmdExec::NewL( MVtEngCommandHandler& aCommandHandler,

    MVtUiEngineCommandManager& aCommandManager, CEikButtonGroupContainer& aCBA )

    {

    CVtEngCmdExec* self = new ( ELeave ) CVtEngCmdExec( aCommandHandler,

        aCommandManager, aCBA );

    return self;

    }

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

// CVtEngCmdExec::ExecuteCmdLD

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

//

void CVtEngCmdExec::ExecuteCmdLD( const TVtEngCommandId aCommandId )

    {

    __VTPRINTENTER("CVtEngCmdExec::ExecuteCmdLD")

    CleanupStack::PushL( this );

    iCommandId = aCommandId;

    iCommandManager.AddObserverL( *this );

    iCommandHandler.ExecuteL( aCommandId, NULL );

    iCBA.SetCommandSetL( R_VIDEOTELUI_SOFTKEYS_EMPTY );

    iCBA.DrawNow();

    iWait.Start();

    CleanupStack::PopAndDestroy(); // this

    __VTPRINTEXIT("CVtEngCmdExec::ExecuteCmdLD")

    }

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

// CVtEngCmdExec::~CVtEngCmdExec

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

//

CVtEngCmdExec::~CVtEngCmdExec()

    {

    __VTPRINTENTER("CVtEngCmdExec::~CVtEngCmdExec")

    if ( iWait.IsStarted())

        {

        __VTPRINT(DEBUG_GEN, "CVtEngCmdExec::~CVtEngCmdExec AsyncStop")

        iWait.AsyncStop();

        }

    iCommandManager.RemoveObserver( *this );

    __VTPRINTEXIT("CVtEngCmdExec::~CVtEngCmdExec")

    }

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

// CVtEngCmdExec::HandleVTCommandPerformedL

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

//

void CVtEngCmdExec::HandleVTCommandPerformedL( TVtEngCommandId aCommand,

        const TInt aError )

    {

    __VTPRINTENTER("CVtEngCmdExec::HandleVTCommandPerformedL")

    if ( iCommandId == aCommand )

        {

         if ( iWait.IsStarted())

            {

            __VTPRINT(DEBUG_GEN, "CVtEngCmdExec::HandleVTCommandPerformedL AsyncStop")

            iWait.AsyncStop();

            }

        else

            {

            // request already completed

            }

        }

    else

        {

        // wrong command ID

        }

    __VTPRINTEXIT("CVtEngCmdExec::HandleVTCommandPerformedL")

    }

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

// CVtEngCmdExec::CVtEngCmdExec

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

//

CVtEngCmdExec::CVtEngCmdExec( MVtEngCommandHandler& aCommandHandler,

    MVtUiEngineCommandManager& aCommandManager, CEikButtonGroupContainer& aCBA )

    : iCommandHandler( aCommandHandler ),

      iCommandManager( aCommandManager ), iCBA( aCBA )

    {

    }

/**

* Encapsulates all instances related to user interface.

* @since Series 60 2.6

*/

class CVtUiAppUi::CInstance

    : public CBase

    {

    public: // Constructors and destructors

        /**

        * Two-phased constructor.

        * @param aAppUi reference to application UI.

        */

        static CInstance* NewL( CVtUiAppUi& aAppUi );

        /**

        * Destructor.

        */

        ~CInstance();

        /**

        * Called when side volume key is pressed.

        */

        void VolumeKeyPressedL();

        /**

        * Create remote video control.

        */        

        void CreateRemoteVideoControl();

    private:

        /**

        * Constructor.

        */

        CInstance( CVtUiAppUi& aAppUi );

        /**

        * Symbian OS constructor.

        */

        void ConstructL();

        /**

        * Relayout controls.

        */

        void LayoutChanged();

    private:

        // Parent can access members.

        friend class CVtUiAppUi;

        // Ref to application UI.

        CVtUiAppUi& iAppUi;

        // Owned bitmap manager.

        CVtUiBitmapManager* iBitmapManager;

        // ETrue if iMainControl has been added to stack.

        TBool iMainControlInStack;