/*

* 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:

*

* Description:  SysInfoPlugin implementation

*

*/

// INCLUDE FILES

#include "../../../symbian_version.hrh"

#include "HtiScreenshotServicePlugin.h"

#include <HtiDispatcherInterface.h>

#include <HtiLogging.h>

#include <imageconversion.h>

#include <ezcompressor.h>

#include <hal.h>

#include <AknLayoutConfig.h>

#include <apgtask.h> 

#include <AknCapServerDefs.h>

#if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )

#include <alf/alfdrawer.h>

#endif

// CONSTANTS

const static TUid KScreenshotServiceUid = {0x1020DEC3};

enum TScreenCommands

    {

    // Normal screencapture

    ECmdScreen                = 0x01,

    ECmdScreenRegion          = 0x02,

    ECmdScreenZip             = 0x03,

    ECmdScreenRegionZip       = 0x04,

    // Text recognition

    ECmdTextRcg               = 0x10,

    ECmdTextRcg_u             = 0x11,

    // Text bitmap

    ECmdTextBitmap            = 0x12,

    ECmdTextBitmap_u          = 0x13,

    // Screencapture in series

    ECmdScreenSeries          = 0x21,

    ECmdScreenRegionSeries    = 0x22,

    ECmdScreenZipSeries       = 0x23,

    ECmdScreenRegionZipSeries = 0x24,

    // Selects the screen to use

    ECmdSelectScreen          = 0x30,

    // Gets the current screen size and orientation

    ECmdScreenMode            = 0x3A,

    // Rotates the screen to portrait or landscape

    ECmdRotateScreen          = 0x3B,

    // Screencapture on updated part of screen only

    ECmdDeltaCaptureMask           = 0x80,

    ECmdDeltaScreen                = 0x81,

    ECmdDeltaScreenRegion          = 0x82,

    ECmdDeltaScreenZip             = 0x83,

    ECmdDeltaScreenRegionZip       = 0x84,

    ECmdDeltaScreenReset           = 0x85

    //ECmdDeltaScreenSeries          = 0xA1,

    //ECmdDeltaScreenRegionSeries    = 0xA2,

    //ECmdDeltaScreenZipSeries       = 0xA3,

    //ECmdDeltaScreenRegionZipSeries = 0xA4

    };

enum TScreenResponse

    {

    ERspOk = 0xF0,

    ERspNotFound = 0xF1

    };

enum THtiFontAttributes

    {

    EHtiFontAttBold = 0x01,

    EHtiFontAttItalic = 0x02,

    EHtiFontAttNotAA = 0x04,

    EHtiFontAttPrintPositionFlag = 0x08,

    EHtiFontAttPrintPositionValue = 0x10

    };

const static TInt KHtiFontAttSuperscriptValue = 0;

const static TInt KHtiFontAttSubscriptValue = 1;

//1 byte for cmd and 2*4 for 4 coordinates

const static TInt KMinScreenRegionCmdLength = 9;

const static TInt KScreenDisplayOffset = 1;

const static TInt KScreenMIMEOffset = KScreenDisplayOffset + 1;

const static TInt KScreenScreenNumber = KScreenMIMEOffset + 8;

const static TInt KRegionDisplayOffset = KMinScreenRegionCmdLength;

const static TInt KRegionMIMEOffset = KRegionDisplayOffset + 1;

const static TInt KRegionScreenNumber = KRegionMIMEOffset + 8;

const static TInt KSeriesDurationOffset = 1;

const static TInt KSeriesIntervalOffset = KSeriesDurationOffset + 4;

const static TInt KSeriesDisplayOffset = KSeriesIntervalOffset + 4;

const static TInt KSeriesMIMEOffset = KSeriesDisplayOffset + 1;

const static TInt KSeriesScreenNumber = KSeriesMIMEOffset + 8;

const static TInt KMinSeriesCmdLength = KSeriesMIMEOffset;

const static TInt KRegionSeriesTlX = KSeriesDisplayOffset + 1;

const static TInt KRegionSeriesTlY = KRegionSeriesTlX + 2;

const static TInt KRegionSeriesBlX = KRegionSeriesTlY + 2;

const static TInt KRegionSeriesBlY = KRegionSeriesBlX + 2;

const static TInt KRegionSeriesMIMEOffset = KRegionSeriesBlY + 2;

const static TInt KRegionSeriesScreenNumber = KRegionSeriesMIMEOffset + 8;

const static TInt KMinRegionSeriesCmdLength = KRegionSeriesMIMEOffset;

const static TInt KDeltaResetCmdLength = 1;

const static TInt KScreenModeCmdLength = 1;

const static TInt KScreenNrOffset = 1;

const static TInt KSelectScreenCmdLength = 2;

const static TInt KRotateScreenCmdLength = 2;

_LIT( KSeriesShotPath, "c:\\Hti\\SeriesShot\\" );

//errors' descriptions

_LIT8( KErrDescrInvalid, "invalid arguments" );

_LIT8( KErrDescrInvalidMode, "invalid color mode" );

_LIT8( KErrDescrRegiontEmpty, "region is empty" );

_LIT8( KErrDescrRegionNotNormailized, "region is not normalized" );

_LIT8( KErrDescrRegionOutOfScreen, "region is out of screen" );

_LIT8( KErrDescrUnknownCommand, "unknown command" );

_LIT8( KErrDescrFailedConvert, "failed to convert to image format" );

_LIT8( KErrDescrFailedCompress, "failed to compress" );

_LIT8( KErrDescrMIMENotSupported, "MIME type not supported" );

_LIT8( KErrDescrScreenNotSupported, "screen not supported" );

_LIT( KScreenshotPanic, "Screenshot plug-in invalid state" );

//_LIT(KS60Sans, "Series 60 Sans");

//_LIT(KS60SansTitleBold, "Series 60 Sans TitleSmBd");

//const TInt KFonHeighMin = 110;

//const TInt KFonHeighMax = 190;

/*

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

void CHtiScreenshotServicePlugin::InitFontCache()

    {

    //temporary

    //just put harcoded data

    //should be either external file or auto-defined based on logical fonts

    //or some test app

    TFontSpec fs;

    fs.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

    //primary font

    fs.iTypeface.iName = KS60Sans;

    fs.iHeight = 161;

    fs.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

    iFontCache.Append(fs);

    fs.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);

    //Series 60 Sans TitleSmBd, 183

    fs.iTypeface.iName = KS60SansTitleBold;

    fs.iHeight = 183;

    iFontCache.Append(fs);

    //Series 60 Sans TitleSmBd, 172

    fs.iTypeface.iName = KS60SansTitleBold;

    fs.iHeight = 172;

    iFontCache.Append(fs);

    //Series 60 Sans,           122

    fs.iTypeface.iName = KS60Sans;

    fs.iHeight = 122;

    iFontCache.Append(fs);

    //Series 60 Sans,           116

    fs.iTypeface.iName = KS60Sans;

    fs.iHeight = 116;

    iFontCache.Append(fs);

    //Series 60 Sans TitleSmBd, 138

    fs.iTypeface.iName = KS60SansTitleBold;

    fs.iHeight = 138;

    iFontCache.Append(fs);

    }

*/

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

TInt ImageDifferenceL( CFbsBitmap* aImage1, CFbsBitmap* aImage2,

                       CFbsBitmap* &aResult, TRect &aRect )

    {

    HTI_LOG_TEXT( "ImageDifferenceL()" );

    // By default return coordinates of the full image

    aRect = TRect( 0, 0, aImage2->SizeInPixels().iWidth,

                  aImage2->SizeInPixels().iHeight );

//1. check that aImage1 and aImage2 are valid and can be compared

    if ( aImage1 == NULL || aImage2 == NULL )

        {

        HTI_LOG_TEXT( "return KErrArgument" );

        return KErrArgument;

        }

    if ( aImage1->SizeInPixels() != aImage2->SizeInPixels() )

        {

        HTI_LOG_TEXT( "return KErrGeneral (size)" );

        return KErrGeneral;

        }

    if ( aImage1->DisplayMode() != aImage2->DisplayMode() )

        {

        HTI_LOG_TEXT( "return KErrGeneral (displaymode)" );

        return KErrGeneral;

        }

//2. iterate through images from each border and compare to findout outline for diff region

    TSize orgSize = aImage1->SizeInPixels();

    TBitmapUtil srcBmpIterator1( aImage1 );

    TBitmapUtil srcBmpIterator2( aImage2 );

    srcBmpIterator1.Begin( TPoint( 0, 0 ) );

    srcBmpIterator2.Begin( TPoint( 0, 0 ), srcBmpIterator1 );

    TRect diffOutline = TRect( -1, -1, -1, -1 );

    //2.1 top border iteration

    TPoint c( 0,0 );

    for ( ; c.iY < orgSize.iHeight && diffOutline.iTl.iY == -1; ++c.iY )

        {

        c.iX = 0;

        srcBmpIterator1.SetPos( c );

        srcBmpIterator2.SetPos( c );

        for ( ; c.iX < orgSize.iWidth && diffOutline.iTl.iY == -1; ++c.iX )

            {

            if ( srcBmpIterator1.GetPixel() != srcBmpIterator2.GetPixel() )

                {

                diffOutline.iTl.iY = c.iY;

                }

            srcBmpIterator1.IncXPos();

            srcBmpIterator2.IncXPos();

            }

        }

    //2.2 bottom iteration

    c.SetXY( 0, orgSize.iHeight - 1 );

    for ( ; c.iY >= diffOutline.iTl.iY && diffOutline.iBr.iY == -1; --c.iY )

        {

        c.iX = 0;

        srcBmpIterator1.SetPos( c );

        srcBmpIterator2.SetPos( c );

        for (; c.iX < orgSize.iWidth && diffOutline.iBr.iY == -1; ++c.iX )

            {

            if ( srcBmpIterator1.GetPixel() != srcBmpIterator2.GetPixel() )

                {

                diffOutline.iBr.iY = c.iY;

                }

            srcBmpIterator1.IncXPos();

            srcBmpIterator2.IncXPos();

            }

        }

    //2.3 left, goes in vertical lines

    c.SetXY( 0, diffOutline.iTl.iY );

    for ( ; c.iX < orgSize.iWidth && diffOutline.iTl.iX == -1; ++c.iX )

        {

        c.iY = diffOutline.iTl.iY;

        srcBmpIterator1.SetPos( c );

        srcBmpIterator2.SetPos( c );

        for ( ; c.iY <= diffOutline.iBr.iY && diffOutline.iTl.iX == -1; ++c.iY )

            {

            if ( srcBmpIterator1.GetPixel() != srcBmpIterator2.GetPixel() )

                {

                diffOutline.iTl.iX = c.iX;

                }

            srcBmpIterator1.IncYPos();

            srcBmpIterator2.IncYPos();

            }

        }

    //2.4 right, goes in vertical lines

    c.SetXY( orgSize.iWidth - 1, diffOutline.iTl.iY );

    for ( ; c.iX >= diffOutline.iTl.iX && diffOutline.iBr.iX == -1; --c.iX )

        {

        c.iY = diffOutline.iTl.iY;

        srcBmpIterator1.SetPos( c );

        srcBmpIterator2.SetPos( c );

        for ( ; c.iY <= diffOutline.iBr.iY && diffOutline.iBr.iX == -1; ++c.iY )

            {

            if ( srcBmpIterator1.GetPixel() != srcBmpIterator2.GetPixel() )

                {

                diffOutline.iBr.iX = c.iX;

                }

            srcBmpIterator1.IncYPos();

            srcBmpIterator2.IncYPos();

            }

        }

    srcBmpIterator2.End();

    srcBmpIterator1.End();

    //3. if there is some diff create CFbsBitmap in aResult and copy outlined image from aImage2

    if ( diffOutline.iTl.iX == -1 &&

         diffOutline.iTl.iY == -1 &&

         diffOutline.iBr.iX == -1 &&

         diffOutline.iBr.iY == -1 )

        {

        // No difference found

        aRect = TRect( 0, 0, 0, 0 );

        HTI_LOG_TEXT( "return KErrNotFound" );

        return KErrNotFound;

        }

    aRect = diffOutline;

    HTI_LOG_FORMAT( "Tlx - %d", aRect.iTl.iX );

    HTI_LOG_FORMAT( "Tly - %d", aRect.iTl.iY );

    HTI_LOG_FORMAT( "Bty - %d", aRect.iBr.iX );

    HTI_LOG_FORMAT( "Bry - %d", aRect.iBr.iY );

    // The bottom right co-ordinate is not included in the rectange

    // (see TRect documentation) so we need to stretch the rectange

    // for BitBlt to get the correct sized image.

    TRect captureRect( diffOutline.iTl.iX, diffOutline.iTl.iY,

                       diffOutline.iBr.iX + 1, diffOutline.iBr.iY + 1 );

    aResult = new (ELeave) CFbsBitmap();

    User::LeaveIfError( aResult->Create( captureRect.Size(), aImage2->DisplayMode() ) );

    CleanupStack::PushL( aResult );

    CFbsBitmapDevice* bmpDevice = CFbsBitmapDevice::NewL( aResult );

    CleanupStack::PushL( bmpDevice );

    CFbsBitGc* bmpCtx;

    bmpDevice->CreateContext( bmpCtx );

    bmpCtx->BitBlt( TPoint( 0, 0 ), aImage2, captureRect );

    delete bmpCtx;

    bmpCtx = NULL;

    CleanupStack::PopAndDestroy(); // bmpDevice

    CleanupStack::Pop(); // aResult

    HTI_LOG_TEXT( "return KErrNone" );

    return KErrNone;

    }

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

CICLHandler::CICLHandler( CImageEncoder* aService, MICLObserver* anObserver ):

    CActive( EPriorityStandard ),

    iObserver( anObserver ),

    iService( aService )

    {

    CActiveScheduler::Add( this );

    }

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

CICLHandler::~CICLHandler()

    {

    Cancel();

    }

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

void CICLHandler::Start()

    {

    SetActive();

    }

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

void CICLHandler::RunL()

    {

    iObserver->ICLComplete( iStatus.Int() );

    }

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

void CICLHandler::DoCancel()

    {

    iService->Cancel();

    }

/*

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

TInt CICLHandler::RunError(TInt aError)

    {

    }

*/

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

// Create instance of concrete ECOM interface implementation

CHtiScreenshotServicePlugin* CHtiScreenshotServicePlugin::NewL()

    {

    CHtiScreenshotServicePlugin* self = new (ELeave) CHtiScreenshotServicePlugin;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// Constructor

CHtiScreenshotServicePlugin::CHtiScreenshotServicePlugin():

    iScreen( NULL ),

    iEncodedBitmap( NULL ),

    iScreenDevice( NULL ),

    iBitmapEncoder( NULL ),

    iICLHandler( NULL ),

    iCompress( EFalse ),

    iDeltaCapture( EFalse ),

    iPreviousBitmap( NULL )

    {

    }

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

CHtiScreenshotServicePlugin::~CHtiScreenshotServicePlugin()

    {

    HTI_LOG_FUNC_IN( "~CHtiScreenshotServicePlugin" );

    iFontCache.Close();

    delete iScreen;

    delete iEncodedBitmap;

    delete iICLHandler;

    delete iBitmapEncoder;

    delete iScreenDevice;

    delete iSeriesShot;

    if ( iPreviousBitmap )

        delete iPreviousBitmap;

    iWs.Close();

    HTI_LOG_FUNC_OUT( "~CHtiScreenshotServicePlugin" );

    }

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

// Second phase construction.

void CHtiScreenshotServicePlugin::ConstructL()

    {

    HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::ConstructL" );

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

    iScreenDevice = new ( ELeave ) CWsScreenDevice( iWs );

    User::LeaveIfError( iScreenDevice->Construct() );

    //InitFontCache();

    iSeriesShot = CSeriesShot::NewL( this );

    iPreviousBitmap = new ( ELeave ) CFbsBitmap;

    //SelectEncoder( KImageTypeBMPUid );

    HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::ConstructL" );

    }

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

TBool CHtiScreenshotServicePlugin::IsBusy()

    {

    if ( iICLHandler )

        {

        return iICLHandler->IsActive();

        }

    if ( iSeriesShot->IsOngoing() )

        {

        return ETrue;

        }

    return iEncodedBitmap != NULL;

    }

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

inline TInt CHtiScreenshotServicePlugin::ParseInt16( const TUint8* aStart )

    {

    return aStart[0] + (aStart[1]<<8);

    }

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

inline TInt CHtiScreenshotServicePlugin::ParseInt32( const TUint8* aStart )

    {

    return aStart[0] + (aStart[1]<<8) + (aStart[2]<<16) + (aStart[3]<<24);

    }

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

void CHtiScreenshotServicePlugin::SendTextRecgReplyL(

                                    const TBool aResult,

                                    const TRect& aLocation,

                                    const TInt aFontIndex)

    {

    HTI_LOG_FUNC_IN( "SendTextRecgReplyL" );

    HBufC8* sendMsg = HBufC8::NewL( 10 );

    CleanupStack::PushL( sendMsg );

    if ( aResult )

        {

        sendMsg->Des().Append( ERspOk );

        TUint16 co = aLocation.iTl.iX;

        sendMsg->Des().Append( (TUint8*)(&co), 2 );

        co = aLocation.iTl.iY;

        sendMsg->Des().Append( (TUint8*)(&co), 2 );

        co = aLocation.iBr.iX;

        sendMsg->Des().Append( (TUint8*)(&co), 2 );

        co = aLocation.iBr.iY;

        sendMsg->Des().Append( (TUint8*)(&co), 2 );

        sendMsg->Des().Append( (TUint8)aFontIndex );

        }

    else

        {

        sendMsg->Des().Append( ERspNotFound );