/*

* Copyright (c) 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: Juha Kauppinen, Mika Hokkanen

* 

* Description: Photo Browser

*

*/

// INCLUDE FILES

#include "ImagicAppUi.h"

#include <IEImage.h>

#include "ImagicViewBrowser.h"

#include "Imagic.hrh"

#include "MSVSTD.HRH"

#include <avkon.hrh>

#include <ImageConversion.h>

#include <aknutils.h>

#include "ImagicContainerBrowser.h"

//statuspane

#include <eikbtgpc.h> 

#include <avkon.rsg>

//for loading text from resource

#include <aknnotewrappers.h>

#include <stringloader.h>

#include <PhotoBrowser.rsg>

#include "ImagicUtils.h"

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

//

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

// CImagicAppUi::ConstructL()

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

//

void CImagicAppUi::ConstructL()

    {

    DP0_IMAGIC(_L("CImagicAppUi::ConstructL++"));

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

    //HlpLauncher::LaunchHelpApplicationL(iEikonEnv->WsSession(), buf);

    iTNGenerationOnGoing = ETrue;

    iMenuOn = EFalse;

    iAppForeGround = ETrue;

    //Set the font

    //SetFont();

    iImagesLoaded = EFalse;

    iImageIndex = 0;     

    iWzContainerSatus = EFalse;

    //iTotalNumOfImages = 0;

    //iNumOfImagesLoaded = 0;

    //iNumOfFacesLoaded = 0;

    iNumberOfIterations = 0;

    iUIDrawMode = EImages;

    iBrowserContainer = NULL;

#ifdef USE_OOM    

    ROomMonitorSession oomMonitor;

    oomMonitor.Connect();

    TInt errorCode = oomMonitor.RequestFreeMemory( 1024*12 );

    if ( errorCode != KErrNone )

        {

        // try one more time 

        errorCode = oomMonitor.RequestFreeMemory( 1024*12 );

        }

    oomMonitor.Close();

#endif    

    User::LeaveIfError(iFileServer.Connect());

    //Initialises this app UI with standard values.

    //The application’s standard resource file will be read unless

    //the ENoAppResourceFile or ENonStandardResourceFile flags are passed.

    BaseConstructL(0x08 | EAknEnableSkin); // Use ELayoutAwareAppFlag (0x08) to make the application support scalable UI on FP3 devices.

    //Create engine and trap if there is error

    iIEngine = CIEEngine::NewL(*this);

	CleanupStack::PushL(iIEngine);

    //Browser view

    CImagicViewBrowser* viewBrowser = new (ELeave) CImagicViewBrowser;

    CleanupStack::PushL( viewBrowser );

    viewBrowser->ConstructL(this);

    AddViewL( viewBrowser );      // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( viewBrowser );

    iViewIdBrowser = viewBrowser->Id(); // view id to get view from CAknViewAppUi

    SetDefaultViewL( *viewBrowser );

    SetActiveView(BrowserView);

    //disable statuspane to get full screen

    StatusPane()->MakeVisible(EFalse);

    //Creating Utility class

    iImagicUtils = CImagicUtils::NewL(iFileServer);

    //Create timer to release Browser view resources and init opengl

    iPeriodic = CPeriodic::NewL( CActive::EPriorityIdle );

    //Force orientation to be always landscape

    SetOrientationL(CAknAppUiBase::EAppUiOrientationLandscape);

    //SetOrientationL(CAknAppUiBase::EAppUiOrientationPortrait);

	CleanupStack::Pop(iIEngine);	

    DP0_IMAGIC(_L("CImagicAppUi::ConstructL--"));

    }

CArrayFix<TCoeHelpContext>* CImagicAppUi::HelpContextL() const

    {

    /*

    //#warning "Please see comment about help and UID3..."

    CArrayFixFlat<TCoeHelpContext>* array = new(ELeave)CArrayFixFlat<TCoeHelpContext>(1);

    CleanupStack::PushL(array);

    array->AppendL(TCoeHelpContext(KUidrsdApp, KGeneral_Information));

    CleanupStack::Pop(array);

    return array;

    */

    }

void CImagicAppUi::CImagicAppUiReady()

    {

    iIEngine->AppUIReady();

    }

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

// CImagicAppUi::~CImagicAppUi()

// Destructor

// Frees reserved resources

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

//

CImagicAppUi::~CImagicAppUi()

    {

    DP0_IMAGIC(_L("CImagicAppUi::~CImagicAppUi++"));

    if(iImagicUtils)

        {

        delete iImagicUtils;

        iImagicUtils = NULL;

        }

    iWizardBitmapArray.Close();

    if(iPeriodic->IsActive())

        iPeriodic->Cancel();

    delete iPeriodic;

    // Doesn't delete engine yet, since container needs it when destroyed!

    //DestructEngine();

    iFileServer.Close();

    DP0_IMAGIC(_L("CImagicAppUi::~CImagicAppUi--"));

    }

void CImagicAppUi::DestructEngine()

    {

    DP0_IMAGIC(_L("CImagicAppUi::DestructEngine++"));    

    delete iIEngine;

    iIEngine = NULL;

    DP0_IMAGIC(_L("CImagicAppUi::DestructEngine--"));    

    }

/*TInt CImagicAppUi::GetErrorCode()

    {

    return iEngineCreationError;

    }*/

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

// CImagicAppUi::DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane)

//  This function is called by the EIKON framework just before it displays

//  a menu pane. Its default implementation is empty, and by overriding it,

//  the application can set the state of menu items dynamically according

//  to the state of application data.

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

//

void CImagicAppUi::DynInitMenuPaneL(

    TInt /*aResourceId*/,CEikMenuPane* /*aMenuPane*/)

    {

    DP0_IMAGIC(_L("CImagicAppUi::DynInitMenuPaneL"));

    }

void CImagicAppUi::BrowserContainerInitialized()

    {

    if(((CImagicViewBrowser*) View(iViewIdBrowser))->GetContainer() != NULL)

        {

        iBrowserContainer = ((CImagicViewBrowser*) View(iViewIdBrowser))->GetContainer();

        iBrowserContainer->ImageListChanged(0, EFalse); // TODO: cheap trick to update coords

        }

    }

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

// CImagicAppUi::HandleForegroundEventL(TBool aForeground)

//  This function is called by the  framework when the screen loses or gains focus.

//   i.e. when it goes to the background or to the foreground. Incoming call

//   softnote is an example.

// This event applies to the entire application, all views.

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

//

void CImagicAppUi::HandleForegroundEventL(TBool aForeground)

    {

    DP0_IMAGIC(_L("CImagicAppUi::HandleForegroundEventL++"));

    //SetOrientationL(CAknAppUiBase::EAppUiOrientationPortrait);

    if(iBrowserContainer)

        if (aForeground)

            {

            DP0_IMAGIC(_L("CImagicAppUi::HandleForegroundEventL - App Foreground"));

            //We were switched to foreground

            iAppForeGround = ETrue;

            //ScreenImmeadetaUpdate();

            if(iPeriodic->IsActive())

                iPeriodic->Cancel();

            iIEngine->StartAccSensorMonitoring();

            iBrowserContainer->SetDeleteTextures(EFalse);

            iAppActiveState = ETrue;

            if(iViewNro == BrowserView)

                {

                if(iBrowserContainer && !iBrowserContainer->IsOpenGLInit())

                    {

                    iBrowserContainer->InitAfterPowerSaveL();

                    }

                else

                    {

                    if(iBrowserContainer)

                        iBrowserContainer->EnableDisplayDraw();

                    }

                }

            if(iBrowserContainer)

                {

                iBrowserContainer->DrawNow();

                iBrowserContainer->EnableDisplayDraw();

                }

            }

        else

            {//We were switched to background

            DP0_IMAGIC(_L("CImagicAppUi::HandleForegroundEventL - App Background"));

            iAppForeGround = EFalse;

            //ScreenImmeadetaUpdate();

            if(iViewNro == BrowserView)

                {

                //... disable frame loop timer ...

                //iBrowserContainer->DisableDisplayDraw();

                //... start a timer for 3 seconds to call to a power save callback ...

                iPeriodic->Start( 3000000, 1000000000, TCallBack( CImagicAppUi::TimerCallBack, this ) );

                //iBrowserContainer = ((CImagicViewBrowser*) View(iViewIdBrowser))->GetContainer();

                }

            //iIEngine->StopAccSensorMonitoring();

            iAppActiveState = EFalse;

            if(iBrowserContainer)

                {

                iBrowserContainer->DrawNow();

                iBrowserContainer->DisableDisplayDraw();

                }

            }

    DP0_IMAGIC(_L("CImagicAppUi::HandleForegroundEventL--"));

    }

//Power save timer callback function

//Cleans memory allocations for openGl draving

TInt CImagicAppUi::TimerCallBack(TAny* aInstance)

    {

    DP0_IMAGIC(_L("CImagicAppUi::TimerCallBack++"));

    CImagicAppUi* instance = (CImagicAppUi*) aInstance;

    instance->iIEngine->StopAccSensorMonitoring();

    if(instance->iViewNro == BrowserView)

        {

        if(instance->iBrowserContainer && instance->iBrowserContainer->IsOpenGLInit())

            {

            DP0_IMAGIC(_L("CImagicAppUi::TimerCallBack - DeleteTextures"));

            //instance->iBrowserContainer->DeleteTextures();

            instance->iBrowserContainer->SetDeleteTextures(ETrue);

            }

        }

    DP0_IMAGIC(_L("CImagicAppUi::TimerCallBack--"));

    return 0;

    }

void  CImagicAppUi::SetTNGenerationFlag(TBool aValue)

    {

    iTNGenerationOnGoing = aValue;

    }

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

// CImagicAppUi::HandleKeyEventL(

//     const TKeyEvent& aKeyEvent,TEventCode /*aType*/)

// Here we handle key events: Right and left arrow key

//   to change view.

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

//

TKeyResponse CImagicAppUi::HandleKeyEventL(const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/)

    {

    DP0_IMAGIC(_L("CImagicAppUi::HandleKeyEventL"));

    //No need to handle events here

    return EKeyWasNotConsumed;

    }

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

// CImagicAppUi::HandleCommandL(TInt aCommand)

// Here we handle commands on the application level.

// In addition, each view has their own HandleCommandL()

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

//

void CImagicAppUi::HandleCommandL(TInt aCommand)

    {

    DP0_IMAGIC(_L("CImagicAppUi::HandleCommandL"));

    switch ( aCommand )

        {

        case EEikCmdExit:

            {

            iIEngine->Stop();

            // send to background

            TApaTask apaTask( CEikonEnv::Static()->WsSession() );

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

            apaTask.SendToBackground();

            // Wait until engine is stopped

            while (iIEngine->IsRunning())

                {

                User::After(200000);   // 200ms

                }

            DP0_IMAGIC(_L("CImagicAppUi::HandleCommandL end wait"));

			if(iTNGenerationOnGoing)

				{

				TInt i = KErrNone;

	            //iIEngine->StopFaceDetection(i);

    	        iIEngine->StopTNGeneration(i);

				}

            Exit();

            break;

            }

        case EImagicCmdViewCmd1:

            {

			break;

            }

        // You can add your all application applying commands here.

        // You would handle here menu commands that are valid for all views.

        }

    }

TInt CImagicAppUi::ExitTimerCallBack(TAny* aInstance)

    {

    CImagicAppUi* instance = (CImagicAppUi*) aInstance;

    instance->iNumberOfIterations++;

    if(instance->iTNGenerationOnGoing)

        {

        if(instance->iNumberOfIterations == 10)

            {

            instance->iNumberOfIterations = 0;

            instance->iPeriodic->Cancel();

            //instance->CancelExitDialog();

            instance->iImagicUtils->CancelWaitDialog();

            User::Exit(KErrNone);

            }

        else

            {

            //nothing.. continue...

            }

        }

    else

        {

        instance->iPeriodic->Cancel();

        //instance->CancelExitDialog();

        instance->iImagicUtils->CancelWaitDialog();

        User::Exit(KErrNone);

        }

    return 0;

    }

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

// CImagicAppUi::HandleResourceChangeL( TInt aType )

// Called by framework when layout is changed.

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

//

void CImagicAppUi::HandleResourceChangeL( TInt aType )

    {

    DP0_IMAGIC(_L("CImagicAppUi::HandleResourceChangeL"));

    //on = aType = 268457666, off = aType = 268457667     

    if(iBrowserContainer != NULL)

        {

        if(aType == 268457666)

            {

            iMenuOn = ETrue;

            //ScreenImmeadetaUpdate();

            if(iBrowserContainer)

                {

                iBrowserContainer->SetScreenImmeadetaUpdate(ETrue);

                iBrowserContainer->DisableDisplayDraw();

                }

            }

        else if(aType == 268457667)

            {

            iMenuOn = EFalse;

            //ScreenImmeadetaUpdate();

            if(iBrowserContainer)

                {

                iBrowserContainer->SetScreenImmeadetaUpdate(EFalse);

                iBrowserContainer->EnableDisplayDraw();    

                }

            }

        iBrowserContainer->DrawNow();

        }

    CAknAppUi::HandleResourceChangeL( aType );

    // ADDED FOR SCALABLE UI SUPPORT

    // *****************************

    if ( aType==KEikDynamicLayoutVariantSwitch )

        {

		((CImagicViewBrowser*) View( iViewIdBrowser) )->HandleClientRectChange(  );

		}

    }

TBool CImagicAppUi::IsAppOnTop()

    {

    if(iMenuOn)

        {

        DP0_IMAGIC(_L("CImagicAppUi::IsAppOnTop: EFalse"));

        return EFalse;

        }

    else if(!iAppForeGround)

        {

        DP0_IMAGIC(_L("CImagicAppUi::IsAppOnTop: EFalse"));

        return EFalse;

        }

    else

        {

        DP0_IMAGIC(_L("CImagicAppUi::IsAppOnTop: ETrue"));

        return ETrue;

        }

    }

void CImagicAppUi::ScreenImmeadetaUpdate()

    {

    if(iMenuOn || !iAppForeGround)

        iBrowserContainer->SetScreenImmeadetaUpdate(ETrue);

    else

        iBrowserContainer->SetScreenImmeadetaUpdate(EFalse);

    }

void CImagicAppUi::SetImageIndex(TInt aIndex)

    {

    DP0_IMAGIC(_L("CImagicAppUi::SetImageIndex"));

    if(aIndex >= iIEngine->GetTotalNumOfImages())

        aIndex = 0;

    if(aIndex < 0)

        aIndex = iIEngine->GetTotalNumOfImages()-1;

    iImageIndex = aIndex;

    }

TInt CImagicAppUi::GetImageIndex()

	{

	DP0_IMAGIC(_L("CImagicAppUi::GetImageIndex"));

	return iImageIndex;

	}

#ifdef _ACCELEROMETER_SUPPORTED_

void CImagicAppUi::ImageRotated(TImagicDeviceOrientation aDeviceOrientation)

    {

    DP1_IMAGIC(_L("CImagicAppUi::ImageRotated, angle: %d"),aDeviceOrientation);

    iBrowserContainer->PhoneRotated(aDeviceOrientation);

    }

#endif

void CImagicAppUi::SetActiveView(TUid aViewNro)

	{

	DP0_IMAGIC(_L("CImagicAppUi::SetActiveView"));

	iViewNro = aViewNro;

	}

TUid CImagicAppUi::GetActiveView()

    {

    DP0_IMAGIC(_L("CImagicAppUi::GetActiveView"));

    return iViewNro;

    }