/*------------------------------------------------------------------

 -

 * Software Name : UserEmulator

 * Version       : v4.2.1309

 * 

 * Copyright (c) 2009 France Telecom. All rights reserved.

 * This software is distributed under the License 

 * "Eclipse Public License - v 1.0" the text of which is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * France Telecom 

 *

 * Contributors:

 *------------------------------------------------------------------

 -

 * File Name: ImageCapture.cpp

 * 

 * Created: 13/08/2009

 * Author(s): Marcell Kiss, Reshma Sandeep Das

 *   

 * Description:

 * Active object implementation for Image capture

 *------------------------------------------------------------------

 -

 *

 */

//System Includes

#include <icl\ImageData.h>

#include <icl\ImageCodecData.h>

#include <coemain.h>

#include <PathInfo.h>

#include <bautils.h>

#include <apgwgnam.h>// CApaWindowGroupName

//User Include

#include "ImageCapture.h"

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

// CImageCapture::NewL

// Creates the instance of class and returns it.

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

//

CImageCapture* CImageCapture::NewL(CSettings& aSettings ,MScreenshotObserver& aObserver, CEikonEnv* aEikonEnv)

{

	CImageCapture* self=CImageCapture::NewLC(aSettings, aObserver, aEikonEnv);

	CleanupStack::Pop(); // self;

	return self;

}

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

// CImageCapture::NewLC

// Creates the instance of class and pushes it to the CleanupStack and return

// it.

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

//

CImageCapture* CImageCapture::NewLC(CSettings& aSettings,MScreenshotObserver& aObserver, CEikonEnv* aEikonEnv)

{

	CImageCapture* self = new (ELeave)CImageCapture(aSettings, aObserver, aEikonEnv);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

}

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

// CImageCapture::CImageCapture

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

//

CImageCapture::CImageCapture(CSettings& aSettings,MScreenshotObserver& aObserver, CEikonEnv* aEikonEnv)

    : CActive(CActive::EPriorityStandard),

      iSettings(aSettings),iBitmap(NULL),

      iImageEncoder(NULL),

      iObserver(aObserver),

      iEEnv(aEikonEnv)

{

}

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

// CImageCapture::ConstructL

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

//

void CImageCapture::ConstructL()

{

	CActiveScheduler::Add(this);

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

}

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

// CImageCapture::~CImageCapture

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

//

CImageCapture::~CImageCapture()

{

    Cancel();

    if (iImageEncoder)

    {

       delete iImageEncoder;

       iImageEncoder = 0;

    }

    if(iBitmap)

    	delete iBitmap;

    iTimer.Close();

    iScreenShotStatus = EIdle;

}

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

// CImageCapture::RunL

// Issues request to save Images and notifies the observer after saving the image

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

//

void CImageCapture::RunL()

{

	switch (iScreenShotStatus)

	{

		case EIdle:

		break;

		case EWaiting:

			{

			RWsSession& wsSession = iEEnv->WsSession();

			TInt id = wsSession.GetFocusWindowGroup();

			CApaWindowGroupName* lApaWGName;

			lApaWGName = CApaWindowGroupName::NewLC(wsSession,id);

			TUid uid = lApaWGName->AppUid();

			if(uid.operator ==(iAppUid) )

   			   Fire(ECapturing);

			else

				FireCapture(1000000);

			CleanupStack::PopAndDestroy(); // lApaWGName

			}

			break;

		case ECapturing:

			DoCaptureL();

			break;

		case ESaveComplete:

		default:

			iObserver.PerformNextAction(1);

			delete this;		

	}          

}

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

// CImageCapture::CaptureL

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

//

void CImageCapture::CaptureL(const TDesC& aName,const TDesC& aXmlFileName, TUid aAppUid)

{

	iFileName.Copy(aName);

	iXmlFileName.Copy(aXmlFileName);

	iAppUid = aAppUid;

	if(AknLayoutUtils::PenEnabled() && !(aAppUid.iUid ) )

	{

		User::After(KWait1);

	}

	if(iAppUid.iUid)

		Fire(EWaiting);

	else

		DoCaptureL();

}

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

// Captures the screenshot and store it to a buffer.

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

void CImageCapture::DoCaptureL()

{

    const CWsScreenDevice* screenDevice = CCoeEnv::Static()->ScreenDevice();

	TPixelsTwipsAndRotation sizeAndRotation;

	screenDevice->GetScreenModeSizeAndRotation(

			screenDevice->CurrentScreenMode(), sizeAndRotation);

	if(iBitmap)

		delete iBitmap;

	iBitmap = NULL;

	iBitmap = new (ELeave) CFbsBitmap;

	iBitmap->SetSizeInTwips( screenDevice);

	User::LeaveIfError( iBitmap->Create( screenDevice->SizeInPixels(),screenDevice->DisplayMode() ) );	

	User::LeaveIfError( screenDevice->CopyScreenToBitmap(iBitmap));

	//save it in a file

	DoSaveL(iFileName);	

	iScreenShotStatus = ESaveComplete;

	SetActive();

}

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

// CImageCapture::Fire

// Fires an event. It means set this active object to active, but completes

// the request immediately.

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

void CImageCapture::Fire(TScreenShotStatus aStatus)

{

    iScreenShotStatus = aStatus;

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, KErrNone);

}

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

// CImageCapture::FireCapture

// Fires an event after aTime microseconds.

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

void CImageCapture::FireCapture(TTimeIntervalMicroSeconds32 aTime)

{

    iScreenShotStatus = EWaiting;

    iTimer.After(iStatus, aTime);

    if(!IsActive())

    	SetActive();

}

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

// CImageCapture::DoSaveL

// Saves captured screenshot to a file.

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

void CImageCapture::DoSaveL(const TDesC& aName)

{

    // Fetch the next available file name.

    HBufC* fileName = GetNextFileNameLC(aName);

    CCoeEnv::Static()->FsSession().MkDirAll(*fileName);

    // Set the MIME type

    _LIT8(KMimeTypepng,"image/png");

    TPtrC8 mimeType(KMimeTypepng);

    // Prepares the image data (if applied).

    CFrameImageData* frameImageData = CFrameImageData::NewL();

    CleanupStack::PushL(frameImageData);

    TPngEncodeData* encodeData = new (ELeave) TPngEncodeData();

    encodeData->iPaletted     = EFalse;

    encodeData->iColor        = ETrue;

    encodeData->iBitsPerPixel = 24;

    encodeData->iLevel = TPngEncodeData::EBestCompression;

    User::LeaveIfError(frameImageData->AppendFrameData(encodeData));

   // Creates a new encoder and then convert the bitmap.

    TRAPD(err, iImageEncoder = CImageEncoder::FileNewL(

    		CCoeEnv::Static()->FsSession(), *fileName, mimeType));

    if(err == KErrNone)

    	iImageEncoder->Convert(&iStatus, *iBitmap, frameImageData);

    CleanupStack::PopAndDestroy(frameImageData); // frameImageData

    CleanupStack::PopAndDestroy(fileName);           // fileName

}

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

// CImageCapture::GetNextFileNameLC

// Get the file name

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

HBufC* CImageCapture::GetNextFileNameLC(const TDesC& aName) const

{

    const TInt KNumberLength = 4; // this is to indicate the file numbering,

                                  // e.g. 0001, 0002, etc.

    const TInt KMaxIndex = 10000;

    const TInt KTimeRecordSize = 512;

    TPtrC filePathPtr;

    _LIT(KExtensionpng, ".png");

    _LIT(KSlash,"\\");

    // Gets the file extension.

    TPtrC fileExtension;

    fileExtension.Set(KExtensionpng);

    filePathPtr.Set(iSettings.iLogPath);

    TInt result = filePathPtr.LocateReverse('\\');

    TPtrC string;

    if(result!=KErrNotFound)

    	string.Set(filePathPtr.Left(result+1));

    TBuf8<KTimeRecordSize> fileName;

    fileName.Copy(string);

    if(iXmlFileName.Length()>0)

    {

    	TInt pos=iXmlFileName.LocateReverse('.');

    	TPtrC8 ptr;

    	if(pos!=KErrNotFound)

    	{

    		ptr.Set(iXmlFileName.Left(pos));

    		fileName.Append(ptr);

    	}

		fileName.Append(KSlash);

    }

    fileName.Append(aName);

    HBufC* newFileName = HBufC::NewLC(fileName.Length()+ KNumberLength + fileExtension.Length() + 1);

    TPtr newFileNamePtr(newFileName->Des());

    newFileNamePtr.Copy(fileName);

    // Checks whether aNamexxxx.png already exists on the phone or not.

    // This is to prevent over-riding of any existing images with the same name

    TBool IsFileExist = ETrue;

    TInt index = 1;

    HBufC* buffer = HBufC::NewL(newFileNamePtr.MaxLength());

    TPtr bufferPtr(buffer->Des());

    while ((index < KMaxIndex) && (IsFileExist))

    {

        bufferPtr.Copy(newFileNamePtr);

        bufferPtr.AppendNumFixedWidth(index, EDecimal, KNumberLength);

        bufferPtr.Append(fileExtension);

        if (BaflUtils::FileExists(CCoeEnv::Static()->FsSession(), *buffer))

        {

        	index++;

        }

        else

        {

        	IsFileExist = EFalse;

        }

    }

    delete buffer;

    // If the index exceeds KMaxIndex, then we don't need to format the file name.

    if (index >= KMaxIndex)

    {

    	newFileNamePtr.AppendNum(index);

    }

    else

    {

    	newFileNamePtr.AppendNumFixedWidth(index, EDecimal, KNumberLength);

    }

    newFileNamePtr.Append(fileExtension);

    // If the index greated then KMaxIndex, then rollback to 1

    if (index >= KMaxIndex)

    {

    	index = 1;

    }

    return newFileName;

}

void CImageCapture::DoCancel()

{

   if (iImageEncoder)

   {

	   iImageEncoder->Cancel();

       delete iImageEncoder;

       iImageEncoder = 0;

   }

   iTimer.Cancel();

}