/*

* Copyright (c) 2008-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:    AppUi class 

*

*/

#include "glxappui.h"

#include <avkon.hrh>

#include <StringLoader.h>    

#include <aknnotewrappers.h>

#include <AknUtils.h>

#include <mpxviewutility.h>

#include <mpxcollectionutility.h>

#include <mpxcollectionmessage.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionpath.h>

#include <centralrepository.h>

#include <alf/alfenv.h>

#include <akntoolbar.h>

#include <glxgallery.hrh>

#include <glxcollectionplugincamera.hrh>

#include <glxcollectionpluginall.hrh>

#include <glxcollectionpluginalbums.hrh>

#include <glxcollectionpluginmonths.hrh>

#include <glxcollectionplugintags.hrh>

#include <glxcollectionpluginimageviewer.hrh>

#include <glxcollectionplugintype.hrh>

#include <glxfiltergeneraldefs.h>

#include <glxpanic.h>

#include <glxuistd.h>

#include <glxviewpluginuids.hrh>

#include <glxlog.h>

#include <glxuiutility.h>

#include <glxsettingsmodel.h>

#include <glxupnprenderer.h>

#include <glxcommandhandlers.hrh>

#include <glxzoomstatepublisher.h>

#include <glxnavigationalstate.h>

#include <glxnavigationalstatedefs.h>

#include <glxfullscreenviewplugin.hrh>

#include <glx.rsg>

#include <AknGlobalNote.h>

#include <hal.h>

#include <hal_data.h>

#include <oommonitorsession.h>

#include <glxtracer.h>

#include "glxcachemanager.h"//OOM

//OOM

#include <oommonitorplugin.h>

#include <oommonitorsession.h>

//OOM

#include <glxbackservicewrapper.h>

#include <glxuistd.h>

#include <apgcli.h>

#include "glxiadupdate.h"

//constants

const TInt KGlxGridThumbnailPages          = 9 ;       // 4 page Down + 4 page Up + 1 Visible page = 9 page 

const TInt KGlxFullThumbnailCount         = 11 ;       // 5 Thumnail Front + 5 Thumbnail Rear + 1 Visible = 11 page

#ifdef __MARM

const TInt KGlxMaxMegaPixelsSupportedByCamera = 5242880 ; // 5 MB

#else

const TInt KGlxMaxMegaPixelsSupportedByCamera = 2097152 ; // 2 MB

#endif

const TInt KGlxMaxMemoryToDecodeCapturedPicture = 2 * KGlxMaxMegaPixelsSupportedByCamera ;

const TInt KGlxMemoryForOOMFwk          = 1048576 ; // 1 MB

const TInt KGlxThumbNailRepresentation    = 2;         // Thumbnail Representation; Could be 3 also 

_LIT8( KPhotosSuiteNavigation, "SuiteNavigation" );

_LIT8( KPhotosCaptured, "Captured" );

_LIT8( KPhotosMonths, "Months" );

_LIT8( KPhotosTags, "Tags" );

_LIT8( KPhotosAlbums, "Albums" );

_LIT8( KPhotosAllValue,"Allcs");

_LIT8( KPhotosSuiteExitMessage, "mm://photossuite?action=exit" );

// Matrix uid, needed for activating the suite view.

const TInt KMatrixUid = 0x101F4CD2;

const TInt KCapturedAlbumId = 2 ;

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

// Constructor

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

//

CGlxAppUi::CGlxAppUi()

    {

    }

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

// ConstructL is called by the application framework

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

//

void CGlxAppUi::ConstructL()

    {

    TRACER("void CGlxAppUi::ConstructL()");

    // Enable Avkon skins.

    BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

    // Create navigational state 

    iNavigationalState = CGlxNavigationalState::InstanceL();

    iNavigationalState->AddObserverL( *this );

    // Create Back Stepping Service wrapper

	iBSWrapper = CGlxBackServiceWrapper::NewL( TUid::Uid( KGlxGalleryApplicationUid ) );

	iNavigationalState->SetBackExitStatus(EFalse);

    iFocusLostLowMemory = EFalse;

    // Get an instance of view utility

    iViewUtility = MMPXViewUtility::UtilityL();

    iUiUtility = CGlxUiUtility::UtilityL();

    // Always start in default orientation

    iUiUtility->SetAppOrientationL(EGlxOrientationDefault);

    ReserveMemoryL(EEntryTypeStartUp);

    // publish zoom context, no zoom keys for now

    NGlxZoomStatePublisher::PublishStateL( EFalse );

    iEndKeyPressed = EFalse;

    }

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

// Destructor

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

//

CGlxAppUi::~CGlxAppUi()

    {

    TRACER("CGlxAppUi::~CGlxAppUi()");

	iEndKeyPressed = EFalse;

    if ( iNavigationalState )

        {

        iNavigationalState->RemoveObserver(*this);

        iNavigationalState->Close();

        }

    if ( iViewUtility )

        {

        iViewUtility->Close();

        }

    delete iActivationParam;

    if ( iUiUtility )

        {

        iUiUtility->Close();

        }

    if( iBSWrapper )

        {	

        delete iBSWrapper;    

        }

    if( iIadUpdate )

        {	

    	delete iIadUpdate;

    	}

    }

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

// HandleCommandL

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

//

void CGlxAppUi::HandleCommandL(TInt aCommand)

    {

    TRACER("void CGlxAppUi::HandleCommandL(TInt aCommand)");

    GLX_LOG_INFO1("PHOTOS LOGS: void CGlxAppUi::HandleCommandL(TInt aCommand = %d)",aCommand );

    switch(aCommand)

        {

        case EEikCmdExit:

            {

            // Send message to Menu and exit.

            /**

            * In case of exit is pressed from options menu of photos grid, this flag will be 

            * false. so it will launch matrix menu. If we don't call LaunchMmViewL, in the above 

            * scenario, photos will exit,but photosuite will come. This is misleading to user.

            */

            if(!iEndKeyPressed)

	            {

	            LaunchMmViewL( KPhotosSuiteExitMessage );	

	            }

            iUiUtility->SetExitingState(ETrue);

            Exit();

            }

            break;

        case EAknSoftkeyExit:

            {

			ClosePhotosL();

            GLX_LOG_INFO("CGlxAppUi::HandleCommandL: Exit() being Called");

            Exit();

            }

            break;

        case EAknSoftkeyBack:

            iNavigationalState->ActivatePreviousViewL();

            break;

        default:

            break;

        }

    }

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

// HandleMessageL

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

//

MCoeMessageObserver::TMessageResponse CGlxAppUi::HandleMessageL(

                            TUint32 /*aClientHandleOfTargetWindowGroup*/,

                            TUid aMessageUid, const TDesC8& aMessageParameters)

    {

    TRACER("MCoeMessageObserver::TMessageResponse CGlxAppUi::HandleMessageL(TUint32 aClientHandleOfTargetWindowGroup,TUid aMessageUid, const TDesC8& aMessageParameters)");

    // TO DO: Check if gallery is in background

    MCoeMessageObserver::TMessageResponse

                            response = MCoeMessageObserver::EMessageHandled;

    switch ( aMessageUid.iUid )

		{

        case KGlxActivationCmdShowLastModified:

        case KGlxActivationCameraAlbum:

            HandleActivationMessageL(aMessageParameters);

            break;

        case KGlxActivationPhotosMenu:

        case KGlxActivationCameraView:

        case KGlxActivationMonthsView:

        case KGlxActivationAlbumsView:

        case KGlxActivationTagsView:

        case KGlxActivationAllView:

        	{

            TApaTaskList taskList( iCoeEnv->WsSession() );

        	TApaTask task = taskList.FindApp( TUid::Uid( KGlxGalleryApplicationUid ) );

        	TApaTask taskForeGround = taskList.FindByPos(0); // get fopreground app

	        if ( task.Exists() && task.ThreadId() != taskForeGround.ThreadId() )

		        {

                // No matter which collection is selected,

                // Photos is running in background, bring to foreground

                iEikonEnv->RootWin().SetOrdinalPosition(0);

		        }

        	}

            break;

        default:

            //To prevent Continues Activation of the Same View; Same is Triggered in ProcessCommandParametersL

            HandleActivationMessageL(aMessageParameters);           

            break;

        }

    return response;

    }

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

// ProcessCommandParametersL

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

//

TBool CGlxAppUi::ProcessCommandParametersL(TApaCommand aCommand,

                            TFileName& aDocumentName, const TDesC8& aTail)

    {

    TRACER("TBool CGlxAppUi::ProcessCommandParametersL(TApaCommand aCommand, TFileName& aDocumentName, const TDesC8& aTail)");

    TRAPD(err, HandleActivationMessageL(aCommand, aDocumentName, aTail));

    if ( KErrNone != err )

        {

        }

    if(0 == aTail.CompareC(KNullDesC8))

        {

      	return ETrue;

        }

    else

        {

        //other case

        return EFalse;

        }

    }

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

// Handle navigational state change

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

//

void CGlxAppUi::HandleNavigationalStateChangedL()

    {

    TRACER("void CGlxAppUi::HandleNavigationalStateChangedL()");

    /*

     * This thread chk is added for EDDG-7UUC53. In this scenario we get EPathChanged from MPX.

     * That initiates a viewnavigational change from CGlxNavigationalStateImp  HandleCollectionMessageL()

     * In these types of scenarios we don't want a view switch. So ignoring the event. 

     */

    TApaTaskList taskList( iCoeEnv->WsSession() );

	TApaTask task = taskList.FindApp( TUid::Uid( KGlxGalleryApplicationUid ) );

	TApaTask taskForeGround = taskList.FindByPos(0); // get fopreground app

	if ( task.Exists() && task.ThreadId() != taskForeGround.ThreadId() )

		{

		GLX_LOG_INFO("CGlxAppUi::HandleNavigationalStateChanged: Return ");

		return;

		}

    HBufC* activationParam = iActivationParam;

    iActivationParam = NULL; // release ownership

    CleanupStack::PushL( activationParam );

    if ( TUid::Null() != iStartupViewUid )

        {

        GLX_LOG_INFO("CGlxAppUi::HandleNavigationalStateChanged: Activating startup view");

        // Activate startup view

        iViewUtility->ActivateViewL( iStartupViewUid, activationParam );

        iStartupViewUid = TUid::Null();

        }

    else

        {

        GLX_LOG_INFO("CGlxAppUi::HandleNavigationalStateChanged: Activating view");

        // get ids for scoring a view

        RArray< TUid > scoringIds;

        CleanupClosePushL( scoringIds );

        GetViewScoringIdsL( scoringIds );

        GLX_LOG_INFO1( "CGlxAppUi::HandleNavigationalStateChanged: Uid count %d", scoringIds.Count());

        // let view utility to select the best view based on scoring ids

        iViewUtility->ActivateViewL( scoringIds, activationParam );

        CleanupStack::PopAndDestroy( &scoringIds );

        }

    CleanupStack::PopAndDestroy( activationParam );

    }

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

// Populate array with view scoring ids

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

//

void CGlxAppUi::GetViewScoringIdsL( RArray<TUid>& aIds ) const

    {

    TRACER("void CGlxAppUi::GetViewScoringIdsL( RArray<TUid>& aIds ) const");

    aIds.Reset(); // For maintenance safety

    // get current navigational state

    CMPXCollectionPath* naviState = iNavigationalState->StateLC();

      // no if check in needed here ,it makes the aapui aware of the list view depth

      // to be removed.added by gopa   

    if ( naviState->Levels() >= 1)

        {

        if (iNavigationalState->ViewingMode() == NGlxNavigationalState::EBrowse) 

            {

            // For image viewer collection, goto view mode

            if (naviState->Id() == TMPXItemId(KGlxCollectionPluginImageViewerImplementationUid))

                {

                aIds.AppendL( TUid::Uid(  KGlxViewingModeView ) );

                }

            else

                {

                aIds.AppendL( TUid::Uid(  KGlxViewingModeBrowse ) );

                }

            } 

        else 

            {

            aIds.AppendL( TUid::Uid(  KGlxViewingModeView ) );

            }                 

        }

    if( TUid::Null() != GetViewScoringIdForCollectionPlugin( *naviState ) )

        {

        // add scoring id for collection plugin

        aIds.AppendL( GetViewScoringIdForCollectionPlugin( *naviState ) );

        }

    if( TUid::Null() != ViewScoringIdForNaviStateDepth( *naviState ) )

        {

         // add scoring id for depth in the ui hierarchy

        aIds.AppendL( ViewScoringIdForNaviStateDepth( *naviState ) );

        }

     CleanupStack::PopAndDestroy( naviState );

    }

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

// Handles the foreground events

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

//

 void CGlxAppUi::HandleForegroundEventL( TBool aForeground )

    {

    TRACER("void CGlxAppUi::HandleForegroundEventL( TBool aForeground )");

    // first let base class handle it so that we dont break anything

    CAknViewAppUi::HandleForegroundEventL( aForeground );

    }

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

// Return scoring id for collection plugin

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

//

TUid CGlxAppUi::GetViewScoringIdForCollectionPlugin( const CMPXCollectionPath& aNaviState ) const

    {

    TRACER("TUid CGlxAppUi::GetViewScoringIdForCollectionPluginL( const CMPXCollectionPath& aNaviState ) const");

    GLX_LOG_INFO1( "CGlxAppUi::GetViewScoringIdForCollectionPluginL: Depth %d", aNaviState.Levels() );

    // score view based on collection plugin if not on root level

    if ( aNaviState.Levels() )

        {

        return TUid::Uid( aNaviState.Id( 0 ) );

        }

    // return null as id to be ignored in scoring

    return TUid::Null(); 

    }

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

// Return scoring id for depth

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

//

TUid CGlxAppUi::ViewScoringIdForNaviStateDepth( const CMPXCollectionPath& aNaviState ) const

    {

    TRACER("TUid CGlxAppUi::ViewScoringIdForNaviStateDepthL( const CMPXCollectionPath& aNaviState ) const");

    GLX_LOG_INFO1( "CGlxAppUi::ViewScoringIdForNaviStateDepthL: Level %d", aNaviState.Levels() );

    switch ( aNaviState.Levels() )

        {

        case 0:

            GLX_LOG_INFO1( "CGlxAppUi::ViewScoringIdForNaviStateDepthL: \

                            Depth  case 0 %x", TUid::Uid( KGlxDepthOne ) );

            return TUid::Uid( KGlxDepthOne );

        case 1:

            GLX_LOG_INFO1( "CGlxAppUi::ViewScoringIdForNaviStateDepthL: \

                            Depth case 1 %x", TUid::Uid( KGlxDepthTwo ) );

            return TUid::Uid( KGlxDepthTwo );

        case 2:

            GLX_LOG_INFO1( "CGlxAppUi::GetViewScoringIdForUiHieararchyDepthL: \

                            Depth case 2 %x", TUid::Uid( KGlxDepthThree ) );

            return TUid::Uid( KGlxDepthThree );

        default:

            GLX_LOG_WARNING( "CGlxAppUi::GetViewScoringIdsL: Navigational state deeper than supported" );

            // return null as an id to be ignored in scoring

            return TUid::Null(); 

        }

    }

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

// HandleActivationMessageL

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

//

void CGlxAppUi::HandleActivationMessageL(const TApaCommand& aCommand, 

        const TFileName& aDocumentName, const TDesC8& aData)

    {

    TRACER("void CGlxAppUi::HandleActivationMessageL(const TApaCommand& aCommand, const TFileName& aDocumentName, const TDesC8& aData)");

    GLX_LOG_INFO1("Glx-HandleActivationMessageL() aCommand=%d", aCommand);

    GLX_LOG_INFO1("Glx-HandleActivationMessageL() aDocumentName length=%d",

                                                    aDocumentName.Length());

    delete iActivationParam;

    iActivationParam = NULL;

    if (aDocumentName.Length() > 0 && 0 == aData.CompareC(KNullDesC8) )

        {

        GLX_LOG_INFO("CGlxAppUi::HandleActivationMessageL() Image Viewer!");        

        CMPXCollectionPath* path = CMPXCollectionPath::NewL();

        CleanupStack::PushL(path);

        iNavigationalState->SetBackExitStatus( EFalse );

        path->AppendL( KGlxCollectionPluginImageViewerImplementationUid );

        iNavigationalState->NavigateToL( *path );

        CleanupStack::PopAndDestroy( path );

        }

    else

        {

        GLX_LOG_INFO("CGlxAppUi::HandleActivationMessageL(aData)");        

        HandleActivationMessageL( aData );

        }

    // Introduced to fix bug EMJN-78GH6N. Rowland Cook 10/12/2007

    if (0 != iEikonEnv->RootWin().OrdinalPosition())

        {

        iEikonEnv->RootWin().SetOrdinalPosition(0);

        }

    }

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

// HandleActivationMessageL

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

//

void CGlxAppUi::HandleActivationMessageL(const TDesC8& aData)

    {

    TRACER("void CGlxAppUi::HandleActivationMessageL(const TDesC8& aData)");