1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  SysInfoPlugin implementation

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

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

    21 

    22 

    23 #include "HtiScreenshotServicePlugin.h"

    24 #include <HtiDispatcherInterface.h>

    25 #include <HtiLogging.h>

    26 

    27 #include <imageconversion.h>

    28 #include <ezcompressor.h>

    29 #include <hal.h>

    30 

    31 #include <AknLayoutConfig.h>

    32 #include <apgtask.h> 

    33 #include <AknCapServerDefs.h>

    34 

    35 #if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )

    36 #include <alf/alfdrawer.h>

    37 #endif

    38 

    39 // CONSTANTS

    40 const static TUid KScreenshotServiceUid = {0x1020DEC3};

    41 

    42 enum TScreenCommands

    43     {

    44     // Normal screencapture

    45     ECmdScreen                = 0x01,

    46     ECmdScreenRegion          = 0x02,

    47     ECmdScreenZip             = 0x03,

    48     ECmdScreenRegionZip       = 0x04,

    49 

    50     // Text recognition

    51     ECmdTextRcg               = 0x10,

    52     ECmdTextRcg_u             = 0x11,

    53 

    54     // Text bitmap

    55     ECmdTextBitmap            = 0x12,

    56     ECmdTextBitmap_u          = 0x13,

    57 

    58     // Screencapture in series

    59     ECmdScreenSeries          = 0x21,

    60     ECmdScreenRegionSeries    = 0x22,

    61     ECmdScreenZipSeries       = 0x23,

    62     ECmdScreenRegionZipSeries = 0x24,

    63 

    64     // Selects the screen to use

    65     ECmdSelectScreen          = 0x30,

    66 

    67     // Gets the current screen size and orientation

    68     ECmdScreenMode            = 0x3A,

    69     

    70     // Rotates the screen to portrait or landscape

    71     ECmdRotateScreen          = 0x3B,

    72 

    73     // Screencapture on updated part of screen only

    74     ECmdDeltaCaptureMask           = 0x80,

    75     ECmdDeltaScreen                = 0x81,

    76     ECmdDeltaScreenRegion          = 0x82,

    77     ECmdDeltaScreenZip             = 0x83,

    78     ECmdDeltaScreenRegionZip       = 0x84,

    79     ECmdDeltaScreenReset           = 0x85

    80     //ECmdDeltaScreenSeries          = 0xA1,

    81     //ECmdDeltaScreenRegionSeries    = 0xA2,

    82     //ECmdDeltaScreenZipSeries       = 0xA3,

    83     //ECmdDeltaScreenRegionZipSeries = 0xA4

    84     };

    85 

    86 enum TScreenResponse

    87     {

    88     ERspOk = 0xF0,

    89     ERspNotFound = 0xF1

    90     };

    91 

    92 enum THtiFontAttributes

    93     {

    94     EHtiFontAttBold = 0x01,

    95     EHtiFontAttItalic = 0x02,

    96     EHtiFontAttNotAA = 0x04,

    97     EHtiFontAttPrintPositionFlag = 0x08,

    98     EHtiFontAttPrintPositionValue = 0x10

    99     };

   100 

   101 const static TInt KHtiFontAttSuperscriptValue = 0;

   102 const static TInt KHtiFontAttSubscriptValue = 1;

   103 

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

   105 const static TInt KMinScreenRegionCmdLength = 9;

   106 const static TInt KScreenDisplayOffset = 1;

   107 const static TInt KScreenMIMEOffset = KScreenDisplayOffset + 1;

   108 const static TInt KScreenScreenNumber = KScreenMIMEOffset + 8;

   109 const static TInt KRegionDisplayOffset = KMinScreenRegionCmdLength;

   110 const static TInt KRegionMIMEOffset = KRegionDisplayOffset + 1;

   111 const static TInt KRegionScreenNumber = KRegionMIMEOffset + 8;

   112 

   113 const static TInt KSeriesDurationOffset = 1;

   114 const static TInt KSeriesIntervalOffset = KSeriesDurationOffset + 4;

   115 const static TInt KSeriesDisplayOffset = KSeriesIntervalOffset + 4;

   116 const static TInt KSeriesMIMEOffset = KSeriesDisplayOffset + 1;

   117 const static TInt KSeriesScreenNumber = KSeriesMIMEOffset + 8;

   118 const static TInt KMinSeriesCmdLength = KSeriesMIMEOffset;

   119 

   120 const static TInt KRegionSeriesTlX = KSeriesDisplayOffset + 1;

   121 const static TInt KRegionSeriesTlY = KRegionSeriesTlX + 2;

   122 const static TInt KRegionSeriesBlX = KRegionSeriesTlY + 2;

   123 const static TInt KRegionSeriesBlY = KRegionSeriesBlX + 2;

   124 const static TInt KRegionSeriesMIMEOffset = KRegionSeriesBlY + 2;

   125 const static TInt KRegionSeriesScreenNumber = KRegionSeriesMIMEOffset + 8;

   126 const static TInt KMinRegionSeriesCmdLength = KRegionSeriesMIMEOffset;

   127 

   128 const static TInt KDeltaResetCmdLength = 1;

   129 const static TInt KScreenModeCmdLength = 1;

   130 

   131 const static TInt KScreenNrOffset = 1;

   132 const static TInt KSelectScreenCmdLength = 2;

   133 const static TInt KRotateScreenCmdLength = 2;

   134 

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

   136 

   137 //errors' descriptions

   138 _LIT8( KErrDescrInvalid, "invalid arguments" );

   139 _LIT8( KErrDescrInvalidMode, "invalid color mode" );

   140 _LIT8( KErrDescrRegiontEmpty, "region is empty" );

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

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

   143 _LIT8( KErrDescrUnknownCommand, "unknown command" );

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

   145 _LIT8( KErrDescrFailedCompress, "failed to compress" );

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

   147 _LIT8( KErrDescrScreenNotSupported, "screen not supported" );

   148 

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

   150 

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

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

   153 

   154 //const TInt KFonHeighMin = 110;

   155 //const TInt KFonHeighMax = 190;

   156 /*

   157 // ----------------------------------------------------------------------------

   158 void CHtiScreenshotServicePlugin::InitFontCache()

   159     {

   160     //temporary

   161     //just put harcoded data

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

   163     //or some test app

   164     TFontSpec fs;

   165     fs.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

   166     //primary font

   167     fs.iTypeface.iName = KS60Sans;

   168     fs.iHeight = 161;

   169     fs.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

   170     iFontCache.Append(fs);

   171 

   172     fs.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);

   173 

   174     //Series 60 Sans TitleSmBd, 183

   175     fs.iTypeface.iName = KS60SansTitleBold;

   176     fs.iHeight = 183;

   177     iFontCache.Append(fs);

   178 

   179     //Series 60 Sans TitleSmBd, 172

   180     fs.iTypeface.iName = KS60SansTitleBold;

   181     fs.iHeight = 172;

   182     iFontCache.Append(fs);

   183 

   184     //Series 60 Sans,           122

   185     fs.iTypeface.iName = KS60Sans;

   186     fs.iHeight = 122;

   187     iFontCache.Append(fs);

   188     //Series 60 Sans,           116

   189     fs.iTypeface.iName = KS60Sans;

   190     fs.iHeight = 116;

   191     iFontCache.Append(fs);

   192 

   193     //Series 60 Sans TitleSmBd, 138

   194     fs.iTypeface.iName = KS60SansTitleBold;

   195     fs.iHeight = 138;

   196     iFontCache.Append(fs);

   197     }

   198 */

   199 

   200 // ----------------------------------------------------------------------------

   201 TInt ImageDifferenceL( CFbsBitmap* aImage1, CFbsBitmap* aImage2,

   202                        CFbsBitmap* &aResult, TRect &aRect )

   203     {

   204     HTI_LOG_TEXT( "ImageDifferenceL()" );

   205 

   206     // By default return coordinates of the full image

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

   208                   aImage2->SizeInPixels().iHeight );

   209 

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

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

   212         {

   213         HTI_LOG_TEXT( "return KErrArgument" );

   214         return KErrArgument;

   215         }

   216 

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

   218         {

   219         HTI_LOG_TEXT( "return KErrGeneral (size)" );

   220         return KErrGeneral;

   221         }

   222 

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

   224         {

   225         HTI_LOG_TEXT( "return KErrGeneral (displaymode)" );

   226         return KErrGeneral;

   227         }

   228 

   229 

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

   231     TSize orgSize = aImage1->SizeInPixels();

   232 

   233     TBitmapUtil srcBmpIterator1( aImage1 );

   234     TBitmapUtil srcBmpIterator2( aImage2 );

   235 

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

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

   238 

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

   240 

   241     //2.1 top border iteration

   242     TPoint c( 0,0 );

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

   244         {

   245         c.iX = 0;

   246         srcBmpIterator1.SetPos( c );

   247         srcBmpIterator2.SetPos( c );

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

   249             {

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

   251                 {

   252                 diffOutline.iTl.iY = c.iY;

   253                 }

   254 

   255             srcBmpIterator1.IncXPos();

   256             srcBmpIterator2.IncXPos();

   257             }

   258         }

   259 

   260     //2.2 bottom iteration

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

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

   263         {

   264         c.iX = 0;

   265         srcBmpIterator1.SetPos( c );

   266         srcBmpIterator2.SetPos( c );

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

   268             {

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

   270                 {

   271                 diffOutline.iBr.iY = c.iY;

   272                 }

   273 

   274             srcBmpIterator1.IncXPos();

   275             srcBmpIterator2.IncXPos();

   276             }

   277         }

   278 

   279     //2.3 left, goes in vertical lines

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

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

   282         {

   283         c.iY = diffOutline.iTl.iY;

   284         srcBmpIterator1.SetPos( c );

   285         srcBmpIterator2.SetPos( c );

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

   287 

   288             {

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

   290                 {

   291                 diffOutline.iTl.iX = c.iX;

   292                 }

   293 

   294             srcBmpIterator1.IncYPos();

   295             srcBmpIterator2.IncYPos();

   296             }

   297         }

   298     //2.4 right, goes in vertical lines

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

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

   301         {

   302         c.iY = diffOutline.iTl.iY;

   303         srcBmpIterator1.SetPos( c );

   304         srcBmpIterator2.SetPos( c );

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

   306 

   307             {

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

   309                 {

   310                 diffOutline.iBr.iX = c.iX;

   311                 }

   312 

   313             srcBmpIterator1.IncYPos();

   314             srcBmpIterator2.IncYPos();

   315             }

   316         }

   317     srcBmpIterator2.End();

   318     srcBmpIterator1.End();

   319 

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

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

   322          diffOutline.iTl.iY == -1 &&

   323          diffOutline.iBr.iX == -1 &&

   324          diffOutline.iBr.iY == -1 )

   325         {

   326         // No difference found

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

   328         HTI_LOG_TEXT( "return KErrNotFound" );

   329         return KErrNotFound;

   330         }

   331 

   332     aRect = diffOutline;

   333 

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

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

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

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

   338 

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

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

   341     // for BitBlt to get the correct sized image.

   342 

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

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

   345 

   346     aResult = new (ELeave) CFbsBitmap();

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

   348     CleanupStack::PushL( aResult );

   349 

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

   351     CleanupStack::PushL( bmpDevice );

   352 

   353     CFbsBitGc* bmpCtx;

   354     bmpDevice->CreateContext( bmpCtx );

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

   356 

   357     delete bmpCtx;

   358     bmpCtx = NULL;

   359 

   360     CleanupStack::PopAndDestroy(); // bmpDevice

   361     CleanupStack::Pop(); // aResult

   362 

   363     HTI_LOG_TEXT( "return KErrNone" );

   364     return KErrNone;

   365     }

   366 

   367 // ----------------------------------------------------------------------------

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

   369     CActive( EPriorityStandard ),

   370     iObserver( anObserver ),

   371     iService( aService )

   372     {

   373     CActiveScheduler::Add( this );

   374     }

   375 

   376 // ----------------------------------------------------------------------------

   377 CICLHandler::~CICLHandler()

   378     {

   379     Cancel();

   380     }

   381 

   382 // ----------------------------------------------------------------------------

   383 void CICLHandler::Start()

   384     {

   385     SetActive();

   386     }

   387 

   388 // ----------------------------------------------------------------------------

   389 void CICLHandler::RunL()

   390     {

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

   392     }

   393 

   394 // ----------------------------------------------------------------------------

   395 void CICLHandler::DoCancel()

   396     {

   397     iService->Cancel();

   398     }

   399 

   400 /*

   401 // ----------------------------------------------------------------------------

   402 TInt CICLHandler::RunError(TInt aError)

   403     {

   404 

   405     }

   406 */

   407 

   408 // ----------------------------------------------------------------------------

   409 // Create instance of concrete ECOM interface implementation

   410 CHtiScreenshotServicePlugin* CHtiScreenshotServicePlugin::NewL()

   411     {

   412     CHtiScreenshotServicePlugin* self = new (ELeave) CHtiScreenshotServicePlugin;

   413     CleanupStack::PushL( self );

   414     self->ConstructL();

   415     CleanupStack::Pop();

   416     return self;

   417     }

   418 

   419 // ----------------------------------------------------------------------------

   420 // Constructor

   421 CHtiScreenshotServicePlugin::CHtiScreenshotServicePlugin():

   422     iScreen( NULL ),

   423     iEncodedBitmap( NULL ),

   424     iScreenDevice( NULL ),

   425     iBitmapEncoder( NULL ),

   426     iICLHandler( NULL ),

   427     iCompress( EFalse ),

   428     iDeltaCapture( EFalse ),

   429     iPreviousBitmap( NULL )

   430     {

   431     }

   432 

   433 // ----------------------------------------------------------------------------

   434 CHtiScreenshotServicePlugin::~CHtiScreenshotServicePlugin()

   435     {

   436     HTI_LOG_FUNC_IN( "~CHtiScreenshotServicePlugin" );

   437 

   438     iFontCache.Close();

   439 

   440     delete iScreen;

   441     delete iEncodedBitmap;

   442 

   443     delete iICLHandler;

   444     delete iBitmapEncoder;

   445 

   446     delete iScreenDevice;

   447 

   448     delete iSeriesShot;

   449 

   450     if ( iPreviousBitmap )

   451         delete iPreviousBitmap;

   452 

   453     iWs.Close();

   454     HTI_LOG_FUNC_OUT( "~CHtiScreenshotServicePlugin" );

   455     }

   456 

   457 // ----------------------------------------------------------------------------

   458 // Second phase construction.

   459 void CHtiScreenshotServicePlugin::ConstructL()

   460     {

   461     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::ConstructL" );

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

   463 

   464     iScreenDevice = new ( ELeave ) CWsScreenDevice( iWs );

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

   466 

   467     //InitFontCache();

   468 

   469     iSeriesShot = CSeriesShot::NewL( this );

   470 

   471     iPreviousBitmap = new ( ELeave ) CFbsBitmap;

   472 

   473     //SelectEncoder( KImageTypeBMPUid );

   474     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::ConstructL" );

   475     }

   476 

   477 // ----------------------------------------------------------------------------

   478 TBool CHtiScreenshotServicePlugin::IsBusy()

   479     {

   480     if ( iICLHandler )

   481         {

   482         return iICLHandler->IsActive();

   483         }

   484 

   485     if ( iSeriesShot->IsOngoing() )

   486         {

   487         return ETrue;

   488         }

   489 

   490     return iEncodedBitmap != NULL;

   491     }

   492 

   493 // ----------------------------------------------------------------------------

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

   495     {

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

   497     }

   498 

   499 // ----------------------------------------------------------------------------

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

   501     {

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

   503     }

   504 

   505 // ----------------------------------------------------------------------------

   506 void CHtiScreenshotServicePlugin::SendTextRecgReplyL(

   507                                     const TBool aResult,

   508                                     const TRect& aLocation,

   509                                     const TInt aFontIndex)

   510     {

   511     HTI_LOG_FUNC_IN( "SendTextRecgReplyL" );

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

   513     CleanupStack::PushL( sendMsg );

   514     if ( aResult )

   515         {

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

   517         TUint16 co = aLocation.iTl.iX;

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

   519         co = aLocation.iTl.iY;

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

   521         co = aLocation.iBr.iX;

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

   523         co = aLocation.iBr.iY;

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

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

   526         }

   527     else

   528         {

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

   530         sendMsg->Des().AppendFill( 0, 5 );

   531         }

   532 

   533     User::LeaveIfError( iDispatcher->DispatchOutgoingMessage(

   534                             sendMsg,

   535                             KScreenshotServiceUid) );

   536 

   537     CleanupStack::Pop();

   538     HTI_LOG_FUNC_OUT( "SendTextRecgReplyL" );

   539     }

   540 

   541 // ----------------------------------------------------------------------------

   542 void CHtiScreenshotServicePlugin::CopyUnicode( TDes & aTo, const TDesC8& aFrom )

   543 {

   544     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::CopyUnicode" );

   545     //aTo.Copy( reinterpret_cast<const TUint16*>(aFrom.Ptr()), aFrom.Length() );

   546     TInt len = aFrom.Length()>>1;

   547     aTo.SetLength( len );

   548     for ( TInt i = 0; i < len; ++i )

   549     {

   550         aTo[i] = (TUint16)aFrom[i<<1] + (((TUint16)aFrom[(i<<1)+1])<<8);

   551     }

   552     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::CopyUnicode" );

   553 }

   554 

   555 // ----------------------------------------------------------------------------

   556 TInt CHtiScreenshotServicePlugin::ParseString( const TDesC8& aRequest,

   557                                         TInt anOffset,

   558                                         TBool aUnicode,

   559                                         TDes& aResult)

   560     {

   561     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::ParseString" );

   562     //validate parameters

   563     //if offset outside the string return empty string

   564     if ( anOffset >= aRequest.Size() )

   565         {

   566         return anOffset;

   567         }

   568 

   569     TInt len = aRequest[ anOffset ];

   570     HTI_LOG_FORMAT( "len %d", len );

   571 

   572     if ( len> aResult.MaxLength() )

   573         {

   574         return KErrBadDescriptor;

   575         }

   576 

   577     TInt nextOffset = ( aUnicode ? len * 2 : len ) + anOffset + 1;

   578     HTI_LOG_FORMAT( "nextOffset %d", nextOffset );

   579     HTI_LOG_FORMAT( "reqSize %d", aRequest.Size() );

   580     if ( nextOffset > aRequest.Size() )

   581         {

   582         return KErrArgument;

   583         }

   584 

   585     if ( aUnicode )

   586         {

   587         //const TUint8* ptr = aRequest.Mid( anOffset + 1, len * 2 ).Ptr();

   588         //aResult.Copy( (const TUint16*)ptr, len );

   589         CopyUnicode( aResult, aRequest.Mid( anOffset + 1, len * 2 ) );

   590         }

   591     else

   592         {

   593         aResult.Copy( aRequest.Mid( anOffset + 1, len ) );

   594         }

   595 

   596     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::ParseString" );

   597     return nextOffset;

   598     }

   599 

   600 // ----------------------------------------------------------------------------

   601 TInt CHtiScreenshotServicePlugin::ParseFontSpec( const TDesC8& aRequest,

   602                     TInt anOffset,

   603                     TBool aUnicode,

   604                     TFontSpec& aResult)

   605     {

   606     if ( anOffset >= aRequest.Size() )

   607         {

   608         return KErrArgument;

   609         }

   610 

   611     //get font name

   612     TPtr tn = aResult.iTypeface.iName.Des();

   613     TInt offset = ParseString( aRequest,

   614                     anOffset,

   615                     aUnicode,

   616                     tn );

   617 

   618     if ( offset > anOffset )

   619         {

   620         HTI_LOG_DES(aResult.iTypeface.iName);

   621         //check that we have valid descr

   622         if ( offset + 2 <= aRequest.Size() )

   623             {

   624             aResult.iHeight = ParseInt16( aRequest.Ptr() + offset );

   625             HTI_LOG_FORMAT( "font height %d", aResult.iHeight );

   626             //check style byte

   627             TUint8 style = aRequest[ offset + 2 ];

   628             HTI_LOG_FORMAT( "style %d", style );

   629 

   630             //stroke bit

   631             if ( style & EHtiFontAttBold )

   632                 {

   633                 aResult.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

   634                 }

   635             else

   636                 {

   637                 aResult.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);

   638                 }

   639             //posture

   640             if ( style & EHtiFontAttItalic )

   641                 {

   642                 aResult.iFontStyle.SetPosture(EPostureItalic);

   643                 }

   644             else

   645                 {

   646                 aResult.iFontStyle.SetPosture(EPostureUpright);

   647                 }

   648             //bitmap glyph type

   649             if ( style & EHtiFontAttNotAA )

   650                 {

   651                 aResult.iFontStyle.SetBitmapType( EMonochromeGlyphBitmap );

   652                 }

   653             else

   654                 {

   655                 aResult.iFontStyle.SetBitmapType( EAntiAliasedGlyphBitmap );

   656                 }

   657             //print position

   658             if ( style & EHtiFontAttPrintPositionFlag )

   659                 {

   660                 TInt printPos = style & EHtiFontAttPrintPositionValue;

   661                 if ( printPos == KHtiFontAttSuperscriptValue )

   662                     {

   663                     aResult.iFontStyle.SetPrintPosition( EPrintPosSuperscript );

   664                     }

   665                 else if ( printPos == KHtiFontAttSubscriptValue )

   666                     {

   667                     aResult.iFontStyle.SetPrintPosition( EPrintPosSubscript );

   668                     }

   669                 }

   670             else

   671                 {

   672                 aResult.iFontStyle.SetPrintPosition( EPrintPosNormal );

   673                 }

   674             return offset + 3;

   675             }

   676         else

   677             {

   678             return KErrArgument;

   679             }

   680         }

   681     else

   682         {

   683         return offset<0?offset:KErrArgument;

   684         }

   685     }

   686 

   687 // ----------------------------------------------------------------------------

   688 void CHtiScreenshotServicePlugin::ProcessTextRcgMessageL(

   689                                     const TDesC8& aMessage)

   690     {

   691     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::ProcessTextRcgMessageL" );

   692     TBool unicode = aMessage[0] & 0x1;

   693 

   694     TBuf<0xFF> text;

   695 

   696     TInt offset = ParseString(aMessage, 1, unicode, text);

   697 

   698     HTI_LOG_FORMAT( "offset %d ", offset );

   699     if ( offset > 1 )

   700         {

   701         HTI_LOG_DES(text);

   702 

   703         if ( offset + 1 < aMessage.Size() )

   704             {

   705             TInt numOfFonts = aMessage[ offset ];

   706             HTI_LOG_FORMAT( "num of fonts %d", numOfFonts );

   707             iFontCache.Reset();

   708             TInt nextOffset  = offset + 1;

   709             for ( TInt i = 0; i < numOfFonts; ++i )

   710                 {

   711                 TFontSpec fontSpec;

   712                 nextOffset = ParseFontSpec(aMessage,

   713                                             nextOffset,

   714                                             unicode,

   715                                             fontSpec);

   716                 if ( nextOffset < 0 )

   717                     {

   718                     iDispatcher->DispatchOutgoingErrorMessage(

   719                         nextOffset,

   720                         KErrDescrInvalid,

   721                         KScreenshotServiceUid);

   722                     return;

   723                     }

   724                 else

   725                     {

   726                     iFontCache.Append( fontSpec );

   727                     }

   728                 }

   729 

   730             //parameters parsing END

   731             //get screenshot

   732             TRect empty;

   733             CreateBitmapL( empty, ENone );

   734 

   735             //call text rcg routines

   736             TInt fontIndex;

   737             TRect resultRect;

   738 

   739             //recognize text using fonts from iFontCache

   740             TBool result = RecognizeTextL( text, resultRect, fontIndex );

   741 

   742             SendTextRecgReplyL( result, resultRect, fontIndex );

   743 

   744             delete iScreen;

   745             iScreen = NULL;

   746             }

   747         else

   748             {

   749             //no fonts data

   750             iDispatcher->DispatchOutgoingErrorMessage(

   751                         KErrArgument,

   752                         KErrDescrInvalid,

   753                         KScreenshotServiceUid);

   754 

   755             }

   756         }

   757     else if ( offset == 1 )

   758         {

   759         //empty text

   760         iDispatcher->DispatchOutgoingErrorMessage(

   761                         KErrArgument,

   762                         KErrDescrInvalid,

   763                         KScreenshotServiceUid);

   764         }

   765     else

   766         {

   767         //error

   768         iDispatcher->DispatchOutgoingErrorMessage(

   769                         offset,

   770                         KErrDescrInvalid,

   771                         KScreenshotServiceUid);

   772         }

   773     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::ProcessTextRcgMessageL" );

   774     }

   775 

   776 // ----------------------------------------------------------------------------

   777 void CHtiScreenshotServicePlugin::ProcessTextBitmapMessageL(

   778                                     const TDesC8& aMessage)

   779     {

   780     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::ProcessTextBitmapMessageL" );

   781     TBool unicode = aMessage[0] & 0x1;

   782 

   783     TDisplayMode displayMode = ENone;

   784     //check display

   785     if ( aMessage.Size() > KScreenDisplayOffset )

   786         {

   787         displayMode = (TDisplayMode)aMessage[KScreenDisplayOffset];

   788         if ( displayMode >= EColorLast )

   789             {

   790             iDispatcher->DispatchOutgoingErrorMessage(

   791                             KErrArgument,

   792                             KErrDescrInvalidMode,

   793                             KScreenshotServiceUid);

   794             return;

   795             }

   796         }

   797 

   798     //check mime

   799     TPtrC8 mime;

   800     if ( aMessage[KScreenMIMEOffset] > 0 &&

   801         ( aMessage[KScreenMIMEOffset] + KScreenMIMEOffset+1 ) < aMessage.Size() )

   802         {

   803         mime.Set( aMessage.Mid(KScreenMIMEOffset+1, aMessage[KScreenMIMEOffset] ) );

   804         if ( !IsMIMETypeSupported( mime ) )

   805             {

   806             iDispatcher->DispatchOutgoingErrorMessage(

   807                             KErrArgument,

   808                             KErrDescrMIMENotSupported,

   809                             KScreenshotServiceUid);

   810             return;

   811             }

   812         }

   813     else if ( aMessage[KScreenMIMEOffset] != 0 )

   814         {

   815         iDispatcher->DispatchOutgoingErrorMessage(

   816                         KErrArgument,

   817                         KErrDescrInvalidMode,

   818                         KScreenshotServiceUid);

   819         return;

   820         }

   821 

   822     TBuf<0xFF> text;

   823     TInt preTextOffset = KScreenMIMEOffset + aMessage[KScreenMIMEOffset] + 1;

   824     TInt offset = ParseString( aMessage, preTextOffset, unicode, text );

   825 

   826     HTI_LOG_FORMAT( "offset %d ", offset );

   827     if ( offset == preTextOffset )

   828         {

   829         //empty text

   830         iDispatcher->DispatchOutgoingErrorMessage(

   831                         KErrArgument,

   832                         KErrDescrInvalid,

   833                         KScreenshotServiceUid);

   834         }

   835     else if ( offset < preTextOffset )

   836         {

   837         //error

   838         iDispatcher->DispatchOutgoingErrorMessage(

   839                         offset,

   840                         KErrDescrInvalid,

   841                         KScreenshotServiceUid);

   842         }

   843 

   844     HTI_LOG_DES(text);

   845     TFontSpec fontSpec;

   846     offset = ParseFontSpec(aMessage,

   847                             offset,

   848                             unicode,

   849                             fontSpec);

   850     if ( offset < 0 )

   851         {

   852         iDispatcher->DispatchOutgoingErrorMessage(

   853             offset,

   854             KErrDescrInvalid,

   855             KScreenshotServiceUid);

   856 

   857         return;

   858         }

   859 

   860     //check colors

   861     HTI_LOG_TEXT( "check colors" );

   862     if ( offset + 2*4 != aMessage.Size() )

   863         {

   864         iDispatcher->DispatchOutgoingErrorMessage(

   865             offset,

   866             KErrDescrInvalid,

   867             KScreenshotServiceUid);

   868         return;

   869         }

   870 

   871     //extract colors

   872     TUint32 fgColor = ParseInt32( aMessage.Ptr() + offset );

   873     TUint32 bgColor = ParseInt32( aMessage.Ptr() + offset + 4 );

   874     HTI_LOG_FORMAT( "FG color %d", fgColor );

   875     HTI_LOG_FORMAT( "BG color %d", bgColor );

   876 

   877     //END parsing

   878     //generate and return bitmap

   879     CFont* useFont;

   880 

   881     User::LeaveIfError( iScreenDevice->GetNearestFontToDesignHeightInPixels(

   882                             useFont, fontSpec ) );

   883 

   884     TDisplayMode dm = displayMode==ENone || displayMode==0?

   885                                         iScreenDevice->DisplayMode():

   886                                         displayMode;

   887 

   888 

   889     delete iScreen;

   890     iScreen = NULL;

   891     iScreen = CHtiTextRcg::GetTextBitmapL(

   892                             text,

   893                             useFont,

   894                             TRgb( fgColor ),

   895                             TRgb( bgColor ),

   896                             dm );

   897 

   898     iScreenDevice->ReleaseFont( useFont );

   899 

   900     //Encode iBitmap

   901     iCompress = EFalse;

   902     if ( mime.Length() == 0 )

   903         {

   904         EncodeBitmapL(); //use default encoder BMP

   905         }

   906     else

   907         {

   908         HTI_LOG_DES( mime );

   909         EncodeBitmapL( mime );

   910         }

   911 

   912     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::ProcessTextBitmapMessageL" );

   913     }

   914 

   915 /*

   916 // ----------------------------------------------------------------------------

   917 TBool CHtiScreenshotServicePlugin::RecognizeTextAllL(

   918                         const TDesC& aText,

   919                         TPoint& aResult)

   920     {

   921     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::RecognizeTextAllL" );

   922 

   923     TSize screenRect = iScreenDevice->SizeInPixels();

   924     TInt nofTF = iScreenDevice->NumTypefaces();

   925     HTI_LOG_FORMAT( "Number of typefaces %d", nofTF );

   926     TBool returnValue = EFalse;

   927     for ( TInt i = 0; i < nofTF; ++i )

   928         {

   929         TTypefaceSupport tf;

   930         iScreenDevice->TypefaceSupport(tf, i);

   931 

   932         HTI_LOG_DES(tf.iTypeface.iName);

   933 

   934         if ( tf.iIsScalable )

   935             {

   936             //iterate throuh heighes

   937 

   938             HTI_LOG_FORMAT( "num of heighs %d", tf.iNumHeights );

   939             HTI_LOG_FORMAT( "min h in tw %d", tf.iMinHeightInTwips );

   940             HTI_LOG_FORMAT( "max h in tw %d", tf.iMaxHeightInTwips );

   941             HTI_LOG_FORMAT( "scalable %d", tf.iIsScalable );

   942 

   943             HTI_LOG_TEXT( "-----------------------" );

   944 

   945             TInt minHeight = Max(tf.iMinHeightInTwips, KFonHeighMin );

   946             TInt maxHeight = Min(tf.iMaxHeightInTwips, KFonHeighMax );

   947 

   948             if ( minHeight > maxHeight )

   949                 {

   950                 continue;

   951                 }

   952 

   953             for ( TInt v = 0; v < 2; ++v )

   954                 {

   955                 TInt lastFontHeight = 0;

   956                 for ( TInt fh = minHeight; fh <= maxHeight; ++fh )

   957                     {

   958                     TFontSpec fs( tf.iTypeface.iName, fh );

   959                     fs.iFontStyle.SetBitmapType( EAntiAliasedGlyphBitmap );

   960                     switch ( v )

   961                         {

   962                         case 1:

   963                             {

   964                             fs.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

   965                             HTI_LOG_TEXT( "BOLD" );

   966                             }

   967                             break;

   968                         default:

   969                             {

   970                             HTI_LOG_TEXT( "DEFAULT" );

   971                             }

   972                         }

   973                     HTI_LOG_FORMAT( "hh  %d", fh );

   974 

   975                     CFont* useFont = NULL;

   976 

   977                     iScreenDevice->GetNearestFontToDesignHeightInTwips(useFont, fs);

   978 

   979                     if ( screenRect.iHeight < useFont->HeightInPixels() ||

   980                          screenRect.iWidth < useFont->MaxNormalCharWidthInPixels()

   981                         )

   982                         {

   983                         break;

   984                         }

   985 

   986                     if ( useFont->HeightInPixels() == lastFontHeight )

   987                         {

   988                         continue;

   989                         }

   990 

   991 

   992                     lastFontHeight = useFont->HeightInPixels();

   993 

   994                     returnValue = iTextRcg.RecognizeTextL(

   995                                                 iScreen,

   996                                                 aText,

   997                                                 useFont,

   998                                                 aResult);

   999                     //HTI_LOG_TEXT( "ReleaseFont" );

  1000                     iScreenDevice->ReleaseFont(useFont);

  1001 

  1002                     if ( returnValue )

  1003                         {

  1004                         HTI_LOG_TEXT( "Found" );

  1005                         HTI_LOG_DES( aText );

  1006                         HTI_LOG_DES( tf.iTypeface.iName );

  1007                         HTI_LOG_FORMAT( "Font height in twips %d", fh );

  1008                         HTI_LOG_FORMAT( "X %d", aResult.iX );

  1009                         HTI_LOG_FORMAT( "Y %d", aResult.iY );

  1010                         return returnValue;

  1011                         }

  1012                     }

  1013                 }

  1014             }

  1015         else

  1016             {//non scal. font

  1017             TFontSpec fs( tf.iTypeface.iName,0 ); //height doesn't matter for

  1018                                                 //not scalable font

  1019 

  1020             CFont* useFont = NULL;

  1021             //HTI_LOG_TEXT( "GetFont" );

  1022             iScreenDevice->GetNearestFontToDesignHeightInTwips( useFont, fs );

  1023 

  1024             returnValue = iTextRcg.RecognizeTextL(

  1025                                         iScreen,

  1026                                         aText,

  1027                                         useFont,

  1028                                         aResult );

  1029             //HTI_LOG_TEXT( "ReleaseFont" );

  1030             iScreenDevice->ReleaseFont( useFont );

  1031 

  1032             if ( returnValue )

  1033                 {

  1034                 HTI_LOG_TEXT( "Found" );

  1035                 HTI_LOG_DES( aText );

  1036                 HTI_LOG_DES(tf.iTypeface.iName );

  1037                 HTI_LOG_FORMAT( "X %d", aResult.iX );

  1038                 HTI_LOG_FORMAT( "Y %d", aResult.iY );

  1039                 return returnValue;

  1040                 }

  1041             }

  1042         }

  1043 

  1044     //

  1045 

  1046     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::RecognizeTextAllL" );

  1047     //return returnValue;

  1048     return EFalse;

  1049     }

  1050 */

  1051 

  1052 // ----------------------------------------------------------------------------

  1053 TBool CHtiScreenshotServicePlugin::RecognizeTextL(

  1054                         const TDesC& aText,

  1055                         TRect& aResult,

  1056                         TInt& aFontIndex)

  1057     {

  1058     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::RecognizeTextL" );

  1059 

  1060     TSize screenRect = iScreenDevice->SizeInPixels();

  1061     TInt cacheSize = iFontCache.Count();

  1062     HTI_LOG_FORMAT( "Cache size %d", cacheSize );

  1063 

  1064     TBool returnValue = EFalse;

  1065     for ( TInt i = 0; i < cacheSize; ++i )

  1066         {

  1067         CFont* useFont = NULL;

  1068 

  1069         User::LeaveIfError(iScreenDevice->GetNearestFontToDesignHeightInPixels(

  1070                                 useFont, iFontCache[i] ) );

  1071         if ( iFontCache[i].iFontStyle.BitmapType()==EAntiAliasedGlyphBitmap )

  1072             {

  1073             iTextRcg.SetHint( EHintEdge );

  1074             }

  1075         else

  1076             {

  1077             iTextRcg.SetHint( EHintNone );

  1078             }

  1079 

  1080         //check that font in valid size

  1081         if ( screenRect.iHeight < useFont->HeightInPixels() ||

  1082              screenRect.iWidth < useFont->MaxNormalCharWidthInPixels()

  1083             )

  1084             {

  1085             break;

  1086             }

  1087 

  1088         returnValue = iTextRcg.RecognizeTextL( iScreen, aText, useFont,

  1089                 aResult );

  1090 

  1091         iScreenDevice->ReleaseFont( useFont );

  1092 

  1093         if ( returnValue )

  1094             {

  1095             HTI_LOG_FORMAT( "Found! fontIndex %d", i );

  1096             HTI_LOG_DES( aText );

  1097             HTI_LOG_DES( iFontCache[i].iTypeface.iName );

  1098             HTI_LOG_FORMAT( "TL X %d", aResult.iTl.iX );

  1099             HTI_LOG_FORMAT( "TL Y %d", aResult.iTl.iY );

  1100             HTI_LOG_FORMAT( "BR X %d", aResult.iBr.iX );

  1101             HTI_LOG_FORMAT( "BR Y %d", aResult.iBr.iY );

  1102             aFontIndex = i;

  1103             return returnValue;

  1104             }

  1105         }

  1106 

  1107     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::RecognizeTextL" );

  1108     return EFalse;

  1109     }

  1110 

  1111 /*

  1112 TBool CHtiScreenshotServicePlugin::RecognizeTextL(

  1113                         const TDesC& aText,

  1114                         const TDesC& aTypeface,

  1115                         TPoint& aResult)

  1116     {

  1117     HTI_LOG_FUNC_IN( "RecognizeTextL typeface" );

  1118     //const CFont* fontUsed = NULL;// AknLayoutUtils::FontFromName(aTypeface);

  1119     CFont* useFont = NULL;

  1120     TFontSpec fs(aTypeface, 0);

  1121 

  1122     iScreenDevice->GetNearestFontInTwips(useFont, fs);

  1123 

  1124     TBool returnValue = iTextRcg.RecognizeTextL(iScreen, aText, useFont, aResult);

  1125 

  1126 HTI_LOG_FUNC_OUT( "RecognizeTextL" );

  1127     return returnValue;

  1128 }

  1129 */

  1130 

  1131 // ----------------------------------------------------------------------------

  1132 void CHtiScreenshotServicePlugin::ProcessMessageL(const TDesC8& aMessage,

  1133                 THtiMessagePriority /*aPriority*/)

  1134     {

  1135     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::ProcessMessage");