/*

 * ============================================================================

 *  Name        : hgteleportappui.cpp

 *  Part of     : Hg Teleport

 *  Description : AppUi class

 *  Version     : %version: sa1spcx1#55 %

 *

 *  Copyright © 2008 Nokia.  All rights reserved.

 *  This material, including documentation and any related computer

 *  programs, is protected by copyright controlled by Nokia.  All

 *  rights are reserved.  Copying, including reproducing, storing,

 *  adapting or translating, any or all of this material requires the

 *  prior written consent of Nokia.  This material also contains

 *  confidential information which may not be disclosed to others

 *  without the prior written consent of Nokia.

 * ============================================================================

 *

 */

#include "hgteleportappui.h"

#include "hgteleportappview.h"

#include "hgteleportapplogging.h"

#include "hgteleportdevicestate.h"

#include "hgteleportuid.hrh"

#include "hgteleportcommands.hrh"

#include <akntitle.h>

#include <hlplch.h>

#include <avkon.rsg>

#include <bautils.h>

#include <AknUtils.h>

#include <hgteleport.rsg>

#include <pslninternalcrkeys.h>

#include <oommonitorsession.h>

#include <hal.h>

#include <hal_data.h>

#include <akntranseffect.h>

// AknCapServer UID, used for P&S category

const TUid KTeleportStateCategory = { 0x10207218 };

// Teleport UI, used as P&S key

const TInt KTeleportStateKey = KHgTeleportAppUidValue;

// Values for Teleport launching P&S

const TInt KTeleportBackgroundValue = 1;

const TInt KTeleportForegroundValue = KTeleportBackgroundValue << 1;

const TInt KTeleportShortAppKeyPressed = KTeleportForegroundValue << 1;

const TInt KTeleportLongAppKeyPressed = KTeleportShortAppKeyPressed << 1;

//short/long App key values 

const TInt KAppKeyTypeShort = 1;

const TInt KAppKeyTypeLong = 2;

//values for checking the OOM

const TInt KMemoryRequestAmountInBytes = 524288;

const TInt KMinMemoryAmountInBytes = 524288;

const TInt KMemoryToBeReservedInBytes = 524288; // 512 KB

// time to wait before sending the task to background

// (must give time to animation)

const TInt KWaitBeforeGoingToBackground = 100000;

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

// CHgTeleportAppUi::ConstructL()

// ConstructL is called by the application framework

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

//

void CHgTeleportAppUi::ConstructL()

    {

    HGLOG_CONTEXT( CHgTeleportAppUi::ConstructL, HGLOG_LOCAL );

    HGLOG_IN();

#ifdef _DEBUG

    // create log folder

	_LIT( KLogPath, "c:\\logs\\teleport\\" );

	RFs fs;

	if ( fs.Connect() == KErrNone )

		{

		fs.MkDirAll( KLogPath );

		fs.Close();

		}

#endif

    // Initialise app UI with standard value.

    BaseConstructL( CAknAppUi::EAknEnableSkin | CAknAppUi::EAknEnableMSK );

#ifndef _DEBUG

    // set as system application (in release build) so we never get closed

    iEikonEnv->SetSystem( ETrue );

#endif

    //Initialize effects change observation

    iThemeEffectsEnabledWatcher =

        CHgCenrepListener::NewL( KCRUidThemes, KThemesTransitionEffects, *this );

    CenrepChanged( KThemesTransitionEffects, iThemeEffectsEnabledWatcher->Value() );

    // Hide status pane

    StatusPane()->MakeVisible( EFalse );

    // Change CBA if needed, default is non-touch in rss

    if ( AknLayoutUtils::PenEnabled() )

        {

        Cba()->SetCommandSetL( R_HGTELEPORT_CBA_TOUCH );

        }

    Cba()->MakeVisible(EFalse);

    // Create timer

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

    // Create commonly used instances (device state only?)

    iDeviceState = CHgTeleportDeviceState::NewL();

    // Create UI

    iAppView = CHgTeleportAppView::NewL( ApplicationRect(), *iDeviceState );

    AddToStackL( iAppView );

    //Enable effects

    GfxTransEffect::Enable();

    GfxTransEffect::Register(iAppView,TUid::Uid(KHgTeleportAppUidValue));

    GfxTransEffect::SetTransitionObserver(this);

    // Listen for change in the value of the teleport state property.

    iPropListener = new ( ELeave ) CHgPropertyListener(

            KTeleportStateCategory, KTeleportStateKey, *this );

    // Initialise the application task object with the window group id of

    // our application ( so that it represent our app )

    iApplicationTask.SetWgId( iCoeEnv->RootWin().Identifier() );

    // And finally, go to background.

    MoveAppToBackground( AknTransEffect::ENone );

    HGLOG_OUT();

    }

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

// CHgTeleportAppUi::CHgTeleportAppUi()

// Perform the first phase of two phase construction

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

//

CHgTeleportAppUi::CHgTeleportAppUi(): iForeground( ETrue ),

                                      iApplicationTask( iCoeEnv->WsSession() )

    {

    // no implementation required

    }

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

// CHgTeleportAppUi::~CHgTeleportAppUi()

// Destructor

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

//

CHgTeleportAppUi::~CHgTeleportAppUi()

    {

    if( GfxTransEffect::IsRegistered( iAppView ) )

        {

        GfxTransEffect::Deregister(iAppView);

        }

    GfxTransEffect::SetTransitionObserver(0);

    delete iGoToBackgroundTimer;

    delete iPropListener;

    // destroy UI first

    if ( iAppView )

        {

        RemoveFromStack( iAppView );

        delete iAppView;

        }

    delete iDeviceState;

    delete iMemAllocBuf;

    delete iThemeEffectsEnabledWatcher;

    }

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

// CHgTeleportAppView::EffectsEnabled

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

//

TBool CHgTeleportAppUi::EffectsEnabled() const

    {

    return iEffectsEnabled;

    }

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

// CHgTeleportAppUi::StartTransion

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

//

void CHgTeleportAppUi::StartTransion( TUint aTransitionType )

    {

    if( !EffectsEnabled() )

        {

        return;

        }

    switch(aTransitionType)

        {

    case AknTransEffect::EApplicationStart:

        StartTransition( aTransitionType, 

                         ETrue, 

                         EFalse, 

                         CAknTransitionUtils::EForceVisible);

        break;

    case AknTransEffect::EApplicationExit:

        StartTransition( aTransitionType, 

                         EFalse, 

                         EFalse, 

                         CAknTransitionUtils::EForceInvisible );

        break;

    case AknTransEffect::EApplicationStartRect:

        StartTransition( aTransitionType, 

                         EFalse, 

                         ETrue, 

                         CAknTransitionUtils::EForceInvisible );

        break;

        }

    }

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

// CHgTeleportAppUi::StartTransition

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

//

void CHgTeleportAppUi::StartTransition( TUint aTranstionId,

                                        TBool aVisibility,

                                        TBool aLayers, 

                                        TUint aSubCom )

    {

    const TDesC8* ptr = reinterpret_cast<const TDesC8*>(iAppView);

    GfxTransEffect::Abort(iAppView);

    GfxTransEffect::Begin( iAppView, aTranstionId );

    GfxTransEffect::SetDemarcation( iAppView, iAppView->Rect() );

    GfxTransEffect::NotifyExternalState( ECaptureComponentsBegin, ptr );

    iAppView->MakeVisible( aVisibility );

    CAknTransitionUtils::MakeVisibleSubComponents( 

        iAppView,

        static_cast<CAknTransitionUtils::TMakeVisibleSubComponentsInfo>(aSubCom) );

    GfxTransEffect::NotifyExternalState( ECaptureComponentsEnd, ptr );

    GfxTransEffect::End( iAppView );

    }

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

// CHgTeleportAppUi::TransitionFinished

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

//

void CHgTeleportAppUi::TransitionFinished(const CCoeControl* aControl, 

                                          TUint aAction)

    {

    /*if( aControl == iAppView )

        {

		@TODO IMPLEMENT

        }*/

    }

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

// CHgTeleportAppUi::HandleCommandL()

// Takes care of command handling.

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

//

void CHgTeleportAppUi::HandleCommandL( TInt aCommand )

    {

    switch ( aCommand )

        {

        case EAknCmdExit:

        case EEikCmdExit:

            Exit();

            break;

        case EAknSoftkeyExit:

        case EAknSoftkeyBack:

            // RSK => just hide

            MoveAppToBackground( AknTransEffect::EApplicationExit );

            break;

        case EHgTeleportCmdHelp:

            {

            MoveAppToBackground( AknTransEffect::EApplicationExit );

            CArrayFix<TCoeHelpContext>* buf = CCoeAppUi::AppHelpContextL();

            HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), buf );

            }

            break;

        case EAknSoftkeySelect:

            {

            // select is generated by lsk and msk (see the resource file)

            // Simulate a middle key press to the controls.

            // Note that SimulateKeyEventL must not be used here or else it

            // will end up in an infinite loop.

            TKeyEvent keyEvent;

            keyEvent.iCode = EKeyOK;

            keyEvent.iScanCode = EStdKeyDevice3;

            keyEvent.iModifiers = keyEvent.iRepeats = 0;

            iAppView->OfferKeyEventL( keyEvent, EEventKeyDown );

            iAppView->OfferKeyEventL( keyEvent, EEventKey );

            iAppView->OfferKeyEventL( keyEvent, EEventKeyUp );

            }

            break;

        default:

            break;

        }

    }

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

// CHgTeleportAppUi::HandleForegroundEventL

// Called by the system when the app is moved to foreground or background.

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

//

void CHgTeleportAppUi::HandleForegroundEventL( TBool aForeground )

    {

    HGLOG_CONTEXT( HandleForegroundEventL, HGLOG_LOCAL );

    HGLOG1_IN( "aForeground = %d", aForeground );

    // These calls may be redundant but the functions will do nothing if the

    // state has already been changed.

    // Both this function and the 'manual' MoveAppTo functions must fire the events

    // because in some cases only one of them will run (e.g. when bringing to foreground

    // not with the hw key but by other means etc.)

    if ( aForeground )

        {

        HandleSwitchToForegroundEvent();

        }

    else

        {

        HandleSwitchToBackgroundEvent();

        }

    // Call Base class method

    CAknAppUi::HandleForegroundEventL( aForeground );

    HGLOG_OUT();

    }

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

// CHgTeleportAppUi::PropertyChanged

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

//

void CHgTeleportAppUi::PropertyChanged( TUid aCategory, TUint aKey )

    {

    HGLOG_CONTEXT( PropertyChanged, HGLOG_LOCAL );

    HGLOG_IN();

    TInt value( 0 );

    if ( RProperty::Get( aCategory, aKey, value ) == KErrNone )

        {

        if ( iForeground && (value & KTeleportBackgroundValue) )

            {

            MoveAppToBackground( AknTransEffect::EApplicationExit );

            }

        else if ( !iForeground && (value & KTeleportForegroundValue) )

            {

            MoveAppToForeground( AknTransEffect::EApplicationStart );

            }

        else if( value & KTeleportLongAppKeyPressed )

            {

            if(!iForeground)

                {

                MoveAppToBackground( AknTransEffect::EApplicationExit );

                }

            else

                {

                iAppView->HandleAppKey(KAppKeyTypeLong);

                }

            }

        else if(  value & KTeleportShortAppKeyPressed )

            {

            iAppView->HandleAppKey(KAppKeyTypeShort);

            }

        }

    HGLOG_OUT();

    }

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

// CHgTeleportAppUi::HandleResourceChangeL

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

//

void CHgTeleportAppUi::HandleResourceChangeL( TInt aType )

    {

    // Must call base class implementation first,

    // sizes from LayoutMetricsRect etc. will only be correct after this.

    CAknAppUi::HandleResourceChangeL( aType );

    if( aType == KEikDynamicLayoutVariantSwitch && iAppView )

        {

        iAppView->SetRect( ApplicationRect() );

        }

    // forward event

    iDeviceState->HandleResourceChange( aType );

    iAppView->HandleResourceChange( aType );

    }

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

// CHgTeleportAppUi::MoveAppToBackground()

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

//

void CHgTeleportAppUi::MoveAppToBackground( TUint aTransitionType )

    {

    HGLOG_CONTEXT( MoveAppToBackground, HGLOG_LOCAL );

    HGLOG_IN();

    if ( AknTransEffect::ENone == aTransitionType || !EffectsEnabled() )

        {

        GoToBackgroundTimerCallback( this );

        }

    else

        {

        StartTransion(AknTransEffect::EApplicationExit);

        iGoToBackgroundTimer->Cancel();

        iGoToBackgroundTimer->Start( 

                KWaitBeforeGoingToBackground, 

                0,

                TCallBack( GoToBackgroundTimerCallback, this ) );

        }

    HGLOG_OUT();

    }

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

// CHgTeleportAppUi::CenrepChanged

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

//

void CHgTeleportAppUi::CenrepChanged( TUint32 aKey, TInt aNewValue )

    {

    iEffectsEnabled = !(aNewValue & AknTransEffect::EFullScreenTransitionsOff);

    }

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

// CHgTeleportAppUi::GoToBackgroundTimerCallback

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

//

TInt CHgTeleportAppUi::GoToBackgroundTimerCallback( TAny* aParam )

    {

    CHgTeleportAppUi* self = static_cast<CHgTeleportAppUi*>( aParam );

    if ( self->iGoToBackgroundTimer )

        {

        self->iGoToBackgroundTimer->Cancel();

        }

    // Request window server to bring our application

    // to background

    self->iApplicationTask.SendToBackground();

    // Notify

    self->HandleSwitchToBackgroundEvent();

    return 0;

    }

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

// CHgTeleportAppUi::MoveAppToForeground()

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

//

void CHgTeleportAppUi::MoveAppToForeground( TUint  /*aTransitionType*/ )

    {

    HGLOG_CONTEXT( MoveAppToForeground, HGLOG_LOCAL );

    HGLOG_IN();

    // Request window server to bring our application

    // to foreground

    iApplicationTask.BringToForeground();

    // Notify

    HandleSwitchToForegroundEvent();

    HGLOG_OUT();

    }

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

// CHgTeleportAppUi::HandleSwitchToBackgroundEvent

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

//

void CHgTeleportAppUi::HandleSwitchToBackgroundEvent()

    {

    HGLOG_CONTEXT( HandleSwitchToBackgroundEvent, HGLOG_LOCAL );

    HGLOG_IN();

    // must not do anything if iForeground is already up-to-date

    // exclude cases with dialogs like power menu, memory card

    if( iForeground && !IsFaded() )  

        {

        iForeground = EFalse;

        SetTeleportStateProperty( KTeleportBackgroundValue );

        //allocating extra memory space

        if ( !iMemAllocBuf )

            {

            iMemAllocBuf =

                (TUint8*) User::Alloc( KMemoryToBeReservedInBytes );

            }

        // notify view

        iAppView->HandleSwitchToBackgroundEvent();

        }

    HGLOG_OUT();

    }

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

// CHgTeleportAppUi::HandleSwitchToForegroundEvent

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

//

void CHgTeleportAppUi::HandleSwitchToForegroundEvent()

    {

    HGLOG_CONTEXT( HandleSwitchToForegroundEvent, HGLOG_LOCAL );

    HGLOG_IN();

    // must not do anything if iForeground is already up-to-date

    if ( !iForeground )

        {

        //freeing extra memory space

        delete iMemAllocBuf;

        iMemAllocBuf = NULL;

        TInt freeRamMemory;

        HAL::Get( HALData::EMemoryRAMFree, freeRamMemory );

        if ( freeRamMemory <= KMinMemoryAmountInBytes )

            {

            FreeMemoryRequest();

            }

        iForeground = ETrue;

        SetTeleportStateProperty( KTeleportForegroundValue );

        // notify view

        iAppView->HandleSwitchToForegroundEvent();

        }

    HGLOG_OUT();

    }