/*

* Copyright (c) 2010 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: 

*

*/

#include <s32file.h> 

#include <bautils.h>

#include <pathinfo.h>

#include <apparc.h> 

#include <imageconversion.h>

#include <textresolver.h>

#include <apgtask.h> 

#include <hblabel.h>

#include <hbmessagebox.h>

#include "mainview.h"

#include "sgengine.h"

#include "enginewrapper.h"

#include "gifanimator.h"

#define SC_PRINTS

    #ifdef SC_PRINTS

     #define SC_DEBUG(a) RDebug::Print(a)

     #define SC_DEBUG2(a,b) RDebug::Print(a,b)

    #else

     #define SC_DEBUG(a) 

     #define SC_DEBUG2(a,b)

    #endif

_LIT(KDefaultImageFileName, "Shot");

_LIT(KDefaultVideoFileName, "Video");

#define HIGH_QUALITY_JPEG 97

#define LOW_QUALITY_JPEG 60

#define DEFAULT_SEQ_CAPTURE_DELAY_MS 5000   // 5.000 secs

#define VIDEO_CAPTURE_DELAY 250             // 0.25 secs

#define VIDEO_CAPTURE_MINIMUM_DELAY 200     // 0.20 secs

const TInt KSettingsDrive = EDriveC;

_LIT(KSettingsFileName, "screengrabber_settings.ini");

_LIT(KScreenShotsSubDirectory, "Screen Shots\\");

_LIT(KSGTemporaryDirectory, "\\system\\temp\\screengrabber\\");

#define KEY_CAPTURE_PRIORITY 100            // do not change, this is for window server

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

SGEngine::SGEngine() : CActive(EPriorityStandard)

    {

    // No implementation required

    }

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

SGEngine::~SGEngine()

    {

    TRAP_IGNORE( CleanTemporaryFilesL() );

    if (iFrameImageData)

        delete iFrameImageData;

    if (iPreviouslyCapturedBitmap)

        delete iPreviouslyCapturedBitmap;

    if (iImageEncoder)

        delete iImageEncoder;

    delete iVideoFrameArray;

    Cancel();

    iTimer.Close();

    iFileSession.Close(); 

    }

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

SGEngine* SGEngine::NewLC(EngineWrapper *aEngineWrapper)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aEngineWrapper);

    return self;

    }

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

SGEngine* SGEngine::NewL(EngineWrapper *aEngineWrapper)

    {

    SGEngine* self = SGEngine::NewLC(aEngineWrapper);

    CleanupStack::Pop(); // self;

    return self;

    }

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

void SGEngine::ConstructL(EngineWrapper *aEngineWrapper)

    {

    iEngineWrapper = aEngineWrapper;

    iHashKeyCapturingActivated = EFalse; // Check this

    User::LeaveIfError(iTimer.CreateLocal());

    iVideoFrameArray = new(ELeave) CVideoFrameArray(10000);

    iPreviouslyCapturedBitmap = new(ELeave) CFbsBitmap;

    iCapturingInProgress = EFalse;

    iStopCapturing = EFalse;

    iNumberOfTakenShots = 0;

    iCurrentFrameNumber = 0;

    iHashKeyDown = EFalse;

	CActiveScheduler::Add(this);

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

	// create window group.

    iRootWin = CEikonEnv::Static()->RootWin();

	iRootWin.EnableReceiptOfFocus(EFalse);

    }

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

void SGEngine::RunL(){

    SC_DEBUG(_L("SCREENGRABBER ------------------------------------------------------- RunL begin"));

    switch (iState) 

        {

        // encoding of the image is now finished

        case EEncodingImage: 

            {

            if (iGrabSettings.iCaptureMode == ECaptureModeSingleCapture)

                {

                // single shot done

                CapturingFinishedL( iStatus.Int() );

                }

            else if (iGrabSettings.iCaptureMode == ECaptureModeSequantialCapture)

                {

                // increase the counter    

                iNumberOfTakenShots++;

                // check if we can take more shots or just finish

                if (!iStopCapturing && iStatus.Int()==KErrNone)

                    {

                    // some delay before the next shot can be taken    

                    iState = ESequenceDelay;

                    // some checking that the value of delay is valid

                    TInt delay(iGrabSettings.iSequantialCaptureDelay); //ms

                    if (delay<0 && delay > 999999)

                        delay = DEFAULT_SEQ_CAPTURE_DELAY_MS;

                    iTimer.After(iStatus, delay*1000);

                    SetActive();  

                    }

                else

                    {

                    // finished

                    CapturingFinishedL( iStatus.Int() );

                    }                       

               }

            else

                User::Panic(_L("Wrong mode"), 32);            

            break;

            }

        // delay finished, ready to take the next shot

        case ESequenceDelay: 

            {

            TakeScreenShotAndSaveL();

            break;

            }

        // asked to cancel capturing    

        case ECancelCapturing:

            {

            // finished

            CapturingFinishedL( iStatus.Int() );

            break;

            }

        case ENextVideoFrame:

            {

            // increase the counter

            iCurrentFrameNumber++;

            // check if we can take more frames or just finish

            if (!iStopCapturing && iStatus.Int()==KErrNone)

                {

                // take next frame

                CaptureFrameForVideoL();

                }

            else

                {

                // finished, save video

                SaveVideoL( iStatus.Int() );

                }               

            }

            break;

        case ECancelVideoCapturing:

            {

            // finished, save video

            SaveVideoL( iStatus.Int() );                

            }

            break;

        default:

            {

            break;

            }

        }

    SC_DEBUG(_L("SCREENGRABBER ------------------------------------------------------- RunL end"));

}

void SGEngine::EnableRcpOfFoc(TBool aState)

	{

	iRootWin.EnableReceiptOfFocus(aState);

	}

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

void SGEngine::DoCancel(){

    iTimer.Cancel();

}

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

void SGEngine::LoadDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, TInt& aValue)

    {

    if (aDicFS->IsPresentL(aUid))

        {

        RDictionaryReadStream in;

        in.OpenLC(*aDicFS, aUid);

        aValue = in.ReadInt16L();

        CleanupStack::PopAndDestroy(); // in        

        }

    }

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

void SGEngine::LoadDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, TDes& aValue)

    {

    if (aDicFS->IsPresentL(aUid))

        {

        RDictionaryReadStream in;

        in.OpenLC(*aDicFS, aUid);

        TInt bufLength = in.ReadInt16L();   // get length of descriptor

        in.ReadL(aValue, bufLength);        // get the descriptor itself

        CleanupStack::PopAndDestroy(); // in

        }

    }

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

void SGEngine::LoadSettingsL()

    {

    // set defaults

    iGrabSettings.iCaptureMode = ECaptureModeSingleCapture;

    iGrabSettings.iSingleCaptureHotkey = EHotkeySendKey;

    iGrabSettings.iSingleCaptureImageFormat = EImageFormatPNG;

    iGrabSettings.iSingleCaptureMemoryInUseMultiDrive = EPhoneMemory;

    iGrabSettings.iSingleCaptureFileName.Copy( KDefaultImageFileName );

    iGrabSettings.iSequantialCaptureHotkey = EHotkeySendKey;

    iGrabSettings.iSequantialCaptureImageFormat = EImageFormatPNG;

    iGrabSettings.iSequantialCaptureDelay = DEFAULT_SEQ_CAPTURE_DELAY_MS;

    iGrabSettings.iSequantialCaptureMemoryInUseMultiDrive = EPhoneMemory;

    iGrabSettings.iSequantialCaptureFileName.Copy( KDefaultImageFileName );

    iGrabSettings.iVideoCaptureHotkey = EHotkeySendKey;

    iGrabSettings.iVideoCaptureVideoFormat = EVideoFormatAnimatedGIF;

    iGrabSettings.iVideoCaptureMemoryInUseMultiDrive = EPhoneMemory;    

    iGrabSettings.iVideoCaptureFileName.Copy( KDefaultVideoFileName );

    // make sure that the private path of this app in c-drive exists

	iFileSession.CreatePrivatePath( KSettingsDrive ); // c:\\private\\101fb751\\

    // handle settings always in the private directory 

	if (iFileSession.SetSessionToPrivate( KSettingsDrive ) == KErrNone)

        {

        // open or create a dictionary file store

        CDictionaryFileStore* settingsStore = CDictionaryFileStore::OpenLC(iFileSession, KSettingsFileName, KUidScreenGrabber);

        LoadDFSValueL(settingsStore, KSGSettingCaptureMode,                             iGrabSettings.iCaptureMode);

        LoadDFSValueL(settingsStore, KSGSettingSingleCaptureHotkey,                     iGrabSettings.iSingleCaptureHotkey);

        LoadDFSValueL(settingsStore, KSGSettingSingleCaptureImageFormat,                iGrabSettings.iSingleCaptureImageFormat);

        LoadDFSValueL(settingsStore, KSGSettingSingleCaptureMemoryInUseMultiDrive,      iGrabSettings.iSingleCaptureMemoryInUseMultiDrive);

        LoadDFSValueL(settingsStore, KSGSettingSingleCaptureFileName,                   iGrabSettings.iSingleCaptureFileName);

        LoadDFSValueL(settingsStore, KSGSettingSequantialCaptureHotkey,                 iGrabSettings.iSequantialCaptureHotkey);

        LoadDFSValueL(settingsStore, KSGSettingSequantialCaptureImageFormat,            iGrabSettings.iSequantialCaptureImageFormat);

        LoadDFSValueL(settingsStore, KSGSettingSequantialCaptureDelay,                  iGrabSettings.iSequantialCaptureDelay);

        LoadDFSValueL(settingsStore, KSGSettingSequantialCaptureMemoryInUseMultiDrive,  iGrabSettings.iSequantialCaptureMemoryInUseMultiDrive);

        LoadDFSValueL(settingsStore, KSGSettingSequantialCaptureFileName,               iGrabSettings.iSequantialCaptureFileName);

        LoadDFSValueL(settingsStore, KSGSettingVideoCaptureHotkey,                      iGrabSettings.iVideoCaptureHotkey);

        LoadDFSValueL(settingsStore, KSGSettingVideoCaptureVideoFormat,                 iGrabSettings.iVideoCaptureVideoFormat);

        LoadDFSValueL(settingsStore, KSGSettingVideoCaptureMemoryInUseMultiDrive,       iGrabSettings.iVideoCaptureMemoryInUseMultiDrive);

        LoadDFSValueL(settingsStore, KSGSettingVideoCaptureFileName,                    iGrabSettings.iVideoCaptureFileName);

        CleanupStack::PopAndDestroy(); // settingsStore         

        }

//chesk if all settings are in range - for safety reason, not to set some controls out of range - it causes the crash

	if (!(iGrabSettings.iCaptureMode >= ECaptureModeSingleCapture && iGrabSettings.iCaptureMode <= ECaptureModeVideoCapture))

	    { //give it default value

        iGrabSettings.iCaptureMode = ECaptureModeSingleCapture;

	    }

	if (!(iGrabSettings.iSingleCaptureHotkey >= EHotkeySendKey && iGrabSettings.iSingleCaptureHotkey <= EHotkeyCameraKey1))

	    {

        iGrabSettings.iSingleCaptureHotkey = EHotkeySendKey;

	    }

	if (!(iGrabSettings.iSingleCaptureImageFormat >= EImageFormatPNG && iGrabSettings.iSingleCaptureImageFormat <= EImageFormatGIF))

	    {

        iGrabSettings.iSingleCaptureImageFormat = EImageFormatPNG;

	    }

	if (!(iGrabSettings.iSingleCaptureMemoryInUseMultiDrive >= EPhoneMemory && iGrabSettings.iSingleCaptureMemoryInUseMultiDrive <= EMemoryCard))

	    {

        iGrabSettings.iSingleCaptureMemoryInUseMultiDrive = EPhoneMemory;

	    }

    if (!(iGrabSettings.iSequantialCaptureHotkey >= EHotkeySendKey && iGrabSettings.iSequantialCaptureHotkey <= EHotkeyCameraKey1))

        {

        iGrabSettings.iSequantialCaptureHotkey = EHotkeySendKey;

        }

    if (!(iGrabSettings.iSequantialCaptureImageFormat >= EImageFormatPNG && iGrabSettings.iSequantialCaptureImageFormat <= EImageFormatGIF))

        {

        iGrabSettings.iSequantialCaptureImageFormat = EImageFormatPNG;

        }

    if (!(iGrabSettings.iSequantialCaptureMemoryInUseMultiDrive >= EPhoneMemory && iGrabSettings.iSequantialCaptureMemoryInUseMultiDrive <= EMemoryCard))

        {

        iGrabSettings.iSequantialCaptureMemoryInUseMultiDrive = EPhoneMemory;

        }

    if (!(iGrabSettings.iVideoCaptureHotkey >= EHotkeySendKey && iGrabSettings.iVideoCaptureHotkey <= EHotkeyCameraKey1))

        {

        iGrabSettings.iVideoCaptureHotkey = EHotkeySendKey;

        }

    if (iGrabSettings.iVideoCaptureVideoFormat != EVideoFormatAnimatedGIF)

        {

        iGrabSettings.iVideoCaptureVideoFormat = EVideoFormatAnimatedGIF;

        }

    if (!(iGrabSettings.iVideoCaptureMemoryInUseMultiDrive >= EPhoneMemory && iGrabSettings.iVideoCaptureMemoryInUseMultiDrive <= EMemoryCard))

        {

        iGrabSettings.iVideoCaptureMemoryInUseMultiDrive = EPhoneMemory;

        }

    }

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

void SGEngine::SaveDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, const TInt& aValue)

    {

    RDictionaryWriteStream out;

    out.AssignLC(*aDicFS, aUid);

    out.WriteInt16L(aValue);

    out.CommitL();  

    CleanupStack::PopAndDestroy(1);// out

    }

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

void SGEngine::SaveDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, const TDes& aValue)

    {

    RDictionaryWriteStream out;

    out.AssignLC(*aDicFS, aUid);

    out.WriteInt16L(aValue.Length());       // write length of the descriptor

    out.WriteL(aValue, aValue.Length());    // write the descriptor itself

    out.CommitL();  

    CleanupStack::PopAndDestroy(1);// out

    }

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

void SGEngine::SaveSettingsL(TGrabSettings aGrabSettings)

    {

    // set the new settings

    iGrabSettings = aGrabSettings;

    // handle settings always in c:\\private\\101fb751\\

    if (iFileSession.SetSessionToPrivate( KSettingsDrive ) == KErrNone)

        {

        // delete existing store to make sure that it is clean and not eg corrupted

        if (BaflUtils::FileExists(iFileSession, KSettingsFileName))

            {

            iFileSession.Delete(KSettingsFileName);

            }

        // create a dictionary file store

        CDictionaryFileStore* settingsStore = CDictionaryFileStore::OpenLC(iFileSession, KSettingsFileName, KUidScreenGrabber);

        SaveDFSValueL(settingsStore, KSGSettingCaptureMode,                             iGrabSettings.iCaptureMode);

        SaveDFSValueL(settingsStore, KSGSettingSingleCaptureHotkey,                     iGrabSettings.iSingleCaptureHotkey);

        SaveDFSValueL(settingsStore, KSGSettingSingleCaptureImageFormat,                iGrabSettings.iSingleCaptureImageFormat);

        SaveDFSValueL(settingsStore, KSGSettingSingleCaptureMemoryInUseMultiDrive,      iGrabSettings.iSingleCaptureMemoryInUseMultiDrive);

        SaveDFSValueL(settingsStore, KSGSettingSingleCaptureFileName,                   iGrabSettings.iSingleCaptureFileName);

        SaveDFSValueL(settingsStore, KSGSettingSequantialCaptureHotkey,                 iGrabSettings.iSequantialCaptureHotkey);

        SaveDFSValueL(settingsStore, KSGSettingSequantialCaptureImageFormat,            iGrabSettings.iSequantialCaptureImageFormat);

        SaveDFSValueL(settingsStore, KSGSettingSequantialCaptureDelay,                  iGrabSettings.iSequantialCaptureDelay);

        SaveDFSValueL(settingsStore, KSGSettingSequantialCaptureMemoryInUseMultiDrive,  iGrabSettings.iSequantialCaptureMemoryInUseMultiDrive);

        SaveDFSValueL(settingsStore, KSGSettingSequantialCaptureFileName,               iGrabSettings.iSequantialCaptureFileName);

        SaveDFSValueL(settingsStore, KSGSettingVideoCaptureHotkey,                      iGrabSettings.iVideoCaptureHotkey);

        SaveDFSValueL(settingsStore, KSGSettingVideoCaptureVideoFormat,                 iGrabSettings.iVideoCaptureVideoFormat);

        SaveDFSValueL(settingsStore, KSGSettingVideoCaptureMemoryInUseMultiDrive,       iGrabSettings.iVideoCaptureMemoryInUseMultiDrive);

        SaveDFSValueL(settingsStore, KSGSettingVideoCaptureFileName,                    iGrabSettings.iVideoCaptureFileName);

        settingsStore->CommitL();

        CleanupStack::PopAndDestroy(); // settingsStore             

        }

    }

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

void SGEngine::ActivateCaptureKeysL(TBool aChangeKey)

    {

    // if changing the capture key, capturing needs to be cancelled first

    if (aChangeKey)

        {

        CancelCapturing();

        }

    // get hotkey of the capture

    TInt captureHotkey(0);

    if (iGrabSettings.iCaptureMode == ECaptureModeSingleCapture)

        captureHotkey = iGrabSettings.iSingleCaptureHotkey;

    else if (iGrabSettings.iCaptureMode == ECaptureModeSequantialCapture)

        captureHotkey = iGrabSettings.iSequantialCaptureHotkey;

    else if (iGrabSettings.iCaptureMode == ECaptureModeVideoCapture)

        captureHotkey = iGrabSettings.iVideoCaptureHotkey;

    else

        User::Panic(_L("Wrong mode"), 40);

    // start capturing based on user selected key

    switch (captureHotkey)

        {

        case EHotkeySendKey:

            {

            iCapturedKey    = iRootWin.CaptureKey(EStdKeyYes, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyYes, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            break;

            }

        case EHotkeyPowerKey:

            {

            iCapturedKey    = iRootWin.CaptureKey(EStdKeyDevice2, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyDevice2, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            break;

            }

        case EHotkeySideKey:

            {

            iCapturedKey    = iRootWin.CaptureKey(EStdKeyDevice6, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyDevice6, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            break;            

            }

        case EHotkeyCameraKey1:

            {

            iCapturedKey    = iRootWin.CaptureKey(EStdKeyDevice7, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyDevice7, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            break;            

            }

        default:

            {

            User::Panic(_L("Key not supported"), 100);

            break;

            }

        }

    }

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

void SGEngine::CancelCapturing()

    {

    SC_DEBUG(_L("SCREENGRABBER ------------------------------------------------------- CancelCapturing start"));

    // cancel all captures

    iRootWin.CancelCaptureKey(iCapturedKey);

    iRootWin.CancelCaptureKeyUpAndDowns(iCapturedKeyUnD);