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 "HtiScreenshotServicePlugin.h"

    21 #include <HtiDispatcherInterface.h>

    22 #include <HTILogging.h>

    23 

    24 #include <ImageConversion.h>

    25 #include <EZCompressor.h>

    26 #include <hal.h>

    27 

    28 // CONSTANTS

    29 const static TUid KScreenshotServiceUid = {0x1020DEC3};

    30 

    31 enum TScreenCommands

    32     {

    33     // Normal screencapture

    34     ECmdScreen                = 0x01,

    35     ECmdScreenRegion          = 0x02,

    36     ECmdScreenZip             = 0x03,

    37     ECmdScreenRegionZip       = 0x04,

    38 

    39     // Text recognition

    40     ECmdTextRcg               = 0x10,

    41     ECmdTextRcg_u             = 0x11,

    42 

    43     // Text bitmap

    44     ECmdTextBitmap            = 0x12,

    45     ECmdTextBitmap_u          = 0x13,

    46 

    47     // Screencapture in series

    48     ECmdScreenSeries          = 0x21,

    49     ECmdScreenRegionSeries    = 0x22,

    50     ECmdScreenZipSeries       = 0x23,

    51     ECmdScreenRegionZipSeries = 0x24,

    52 

    53     // Selects the screen to use

    54     ECmdSelectScreen          = 0x30,

    55 

    56     // Gets the current screen size and orientation

    57     ECmdScreenMode            = 0x3A,

    58 

    59     // Screencapture on updated part of screen only

    60     ECmdDeltaCaptureMask           = 0x80,

    61     ECmdDeltaScreen                = 0x81,

    62     ECmdDeltaScreenRegion          = 0x82,

    63     ECmdDeltaScreenZip             = 0x83,

    64     ECmdDeltaScreenRegionZip       = 0x84,

    65     ECmdDeltaScreenReset           = 0x85

    66     //ECmdDeltaScreenSeries          = 0xA1,

    67     //ECmdDeltaScreenRegionSeries    = 0xA2,

    68     //ECmdDeltaScreenZipSeries       = 0xA3,

    69     //ECmdDeltaScreenRegionZipSeries = 0xA4

    70     };

    71 

    72 enum TScreenResponse

    73     {

    74     ERspOk = 0xF0,

    75     ERspNotFound = 0xF1

    76     };

    77 

    78 enum THtiFontAttributes

    79     {

    80     EHtiFontAttBold = 0x01,

    81     EHtiFontAttItalic = 0x02,

    82     EHtiFontAttNotAA = 0x04,

    83     EHtiFontAttPrintPositionFlag = 0x08,

    84     EHtiFontAttPrintPositionValue = 0x10

    85     };

    86 

    87 const static TInt KHtiFontAttSuperscriptValue = 0;

    88 const static TInt KHtiFontAttSubscriptValue = 1;

    89 

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

    91 const static TInt KMinScreenRegionCmdLength = 9;

    92 const static TInt KScreenDisplayOffset = 1;

    93 const static TInt KScreenMIMEOffset = KScreenDisplayOffset + 1;

    94 const static TInt KRegionDisplayOffset = KMinScreenRegionCmdLength;

    95 const static TInt KRegionMIMEOffset = KRegionDisplayOffset + 1;

    96 

    97 

    98 const static TInt KSeriesDurationOffset = 1;

    99 const static TInt KSeriesIntervalOffset = KSeriesDurationOffset + 4;

   100 const static TInt KSeriesDisplayOffset = KSeriesIntervalOffset + 4;

   101 const static TInt KSeriesMIMEOffset = KSeriesDisplayOffset + 1;

   102 const static TInt KMinSeriesCmdLength = KSeriesMIMEOffset;

   103 

   104 const static TInt KRegionSeriesTlX = KSeriesDisplayOffset + 1;

   105 const static TInt KRegionSeriesTlY = KRegionSeriesTlX + 2;

   106 const static TInt KRegionSeriesBlX = KRegionSeriesTlY + 2;

   107 const static TInt KRegionSeriesBlY = KRegionSeriesBlX + 2;

   108 const static TInt KRegionSeriesMIMEOffset = KRegionSeriesBlY + 2;

   109 const static TInt KMinRegionSeriesCmdLength = KRegionSeriesMIMEOffset;

   110 

   111 const static TInt KDeltaResetCmdLength = 1;

   112 const static TInt KScreenModeCmdLength = 1;

   113 

   114 const static TInt KScreenNrOffset = 1;

   115 const static TInt KSelectScreenCmdLength = 2;

   116 

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

   118 

   119 //errors' descriptions

   120 _LIT8( KErrDescrInvalid, "invalid arguments" );

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

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

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

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

   125 _LIT8( KErrDescrUnknownCommand, "unknown command" );

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

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

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

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

   130 

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

   132 

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

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

   135 

   136 //const TInt KFonHeighMin = 110;

   137 //const TInt KFonHeighMax = 190;

   138 /*

   139 // ----------------------------------------------------------------------------

   140 void CHtiScreenshotServicePlugin::InitFontCache()

   141     {

   142     //temporary

   143     //just put harcoded data

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

   145     //or some test app

   146     TFontSpec fs;

   147     fs.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

   148     //primary font

   149     fs.iTypeface.iName = KS60Sans;

   150     fs.iHeight = 161;

   151     fs.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

   152     iFontCache.Append(fs);

   153 

   154     fs.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);

   155 

   156     //Series 60 Sans TitleSmBd, 183

   157     fs.iTypeface.iName = KS60SansTitleBold;

   158     fs.iHeight = 183;

   159     iFontCache.Append(fs);

   160 

   161     //Series 60 Sans TitleSmBd, 172

   162     fs.iTypeface.iName = KS60SansTitleBold;

   163     fs.iHeight = 172;

   164     iFontCache.Append(fs);

   165 

   166     //Series 60 Sans,           122

   167     fs.iTypeface.iName = KS60Sans;

   168     fs.iHeight = 122;

   169     iFontCache.Append(fs);

   170     //Series 60 Sans,           116

   171     fs.iTypeface.iName = KS60Sans;

   172     fs.iHeight = 116;

   173     iFontCache.Append(fs);

   174 

   175     //Series 60 Sans TitleSmBd, 138

   176     fs.iTypeface.iName = KS60SansTitleBold;

   177     fs.iHeight = 138;

   178     iFontCache.Append(fs);

   179     }

   180 */

   181 

   182 // ----------------------------------------------------------------------------

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

   184                        CFbsBitmap* &aResult, TRect &aRect )

   185     {

   186     HTI_LOG_TEXT( "ImageDifferenceL()" );

   187 

   188     // By default return coordinates of the full image

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

   190                   aImage2->SizeInPixels().iHeight );

   191 

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

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

   194         {

   195         HTI_LOG_TEXT( "return KErrArgument" );

   196         return KErrArgument;

   197         }

   198 

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

   200         {

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

   202         return KErrGeneral;

   203         }

   204 

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

   206         {

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

   208         return KErrGeneral;

   209         }

   210 

   211 

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

   213     TSize orgSize = aImage1->SizeInPixels();

   214 

   215     TBitmapUtil srcBmpIterator1( aImage1 );

   216     TBitmapUtil srcBmpIterator2( aImage2 );

   217 

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

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

   220 

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

   222 

   223     //2.1 top border iteration

   224     TPoint c( 0,0 );

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

   226         {

   227         c.iX = 0;

   228         srcBmpIterator1.SetPos( c );

   229         srcBmpIterator2.SetPos( c );

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

   231             {

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

   233                 {

   234                 diffOutline.iTl.iY = c.iY;

   235                 }

   236 

   237             srcBmpIterator1.IncXPos();

   238             srcBmpIterator2.IncXPos();

   239             }

   240         }

   241 

   242     //2.2 bottom iteration

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

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

   245         {

   246         c.iX = 0;

   247         srcBmpIterator1.SetPos( c );

   248         srcBmpIterator2.SetPos( c );

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

   250             {

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

   252                 {

   253                 diffOutline.iBr.iY = c.iY;

   254                 }

   255 

   256             srcBmpIterator1.IncXPos();

   257             srcBmpIterator2.IncXPos();

   258             }

   259         }

   260 

   261     //2.3 left, goes in vertical lines

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

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

   264         {

   265         c.iY = diffOutline.iTl.iY;

   266         srcBmpIterator1.SetPos( c );

   267         srcBmpIterator2.SetPos( c );

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

   269 

   270             {

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

   272                 {

   273                 diffOutline.iTl.iX = c.iX;

   274                 }

   275 

   276             srcBmpIterator1.IncYPos();

   277             srcBmpIterator2.IncYPos();

   278             }

   279         }

   280     //2.4 right, goes in vertical lines

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

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

   283         {

   284         c.iY = diffOutline.iTl.iY;

   285         srcBmpIterator1.SetPos( c );

   286         srcBmpIterator2.SetPos( c );

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

   288 

   289             {

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

   291                 {

   292                 diffOutline.iBr.iX = c.iX;

   293                 }

   294 

   295             srcBmpIterator1.IncYPos();

   296             srcBmpIterator2.IncYPos();

   297             }

   298         }

   299     srcBmpIterator2.End();

   300     srcBmpIterator1.End();

   301 

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

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

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

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

   306          diffOutline.iBr.iY == -1 )

   307         {

   308         // No difference found

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

   310         HTI_LOG_TEXT( "return KErrNotFound" );

   311         return KErrNotFound;

   312         }

   313 

   314     aRect = diffOutline;

   315 

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

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

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

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

   320 

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

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

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

   324 

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

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

   327 

   328     aResult = new (ELeave) CFbsBitmap();

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

   330     CleanupStack::PushL( aResult );

   331 

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

   333     CleanupStack::PushL( bmpDevice );

   334 

   335     CFbsBitGc* bmpCtx;

   336     bmpDevice->CreateContext( bmpCtx );

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

   338 

   339     delete bmpCtx;

   340     bmpCtx = NULL;

   341 

   342     CleanupStack::PopAndDestroy(); // bmpDevice

   343     CleanupStack::Pop(); // aResult

   344 

   345     HTI_LOG_TEXT( "return KErrNone" );

   346     return KErrNone;

   347     }

   348 

   349 // ----------------------------------------------------------------------------

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

   351     CActive( EPriorityStandard ),

   352     iObserver( anObserver ),

   353     iService( aService )

   354     {

   355     CActiveScheduler::Add( this );

   356     }

   357 

   358 // ----------------------------------------------------------------------------

   359 CICLHandler::~CICLHandler()

   360     {

   361     Cancel();

   362     }

   363 

   364 // ----------------------------------------------------------------------------

   365 void CICLHandler::Start()

   366     {

   367     SetActive();

   368     }

   369 

   370 // ----------------------------------------------------------------------------

   371 void CICLHandler::RunL()

   372     {

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

   374     }

   375 

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

   377 void CICLHandler::DoCancel()

   378     {

   379     iService->Cancel();

   380     }

   381 

   382 /*

   383 // ----------------------------------------------------------------------------

   384 TInt CICLHandler::RunError(TInt aError)

   385     {

   386 

   387     }

   388 */

   389 

   390 // ----------------------------------------------------------------------------

   391 // Create instance of concrete ECOM interface implementation

   392 CHtiScreenshotServicePlugin* CHtiScreenshotServicePlugin::NewL()

   393     {

   394     CHtiScreenshotServicePlugin* self = new (ELeave) CHtiScreenshotServicePlugin;

   395     CleanupStack::PushL( self );

   396     self->ConstructL();

   397     CleanupStack::Pop();

   398     return self;

   399     }

   400 

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

   402 // Constructor

   403 CHtiScreenshotServicePlugin::CHtiScreenshotServicePlugin():

   404     iScreen( NULL ),

   405     iEncodedBitmap( NULL ),

   406     iScreenDevice( NULL ),

   407     iBitmapEncoder( NULL ),

   408     iICLHandler( NULL ),

   409     iCompress( EFalse ),

   410     iDeltaCapture( EFalse ),

   411     iPreviousBitmap( NULL )

   412     {

   413     }

   414 

   415 // ----------------------------------------------------------------------------

   416 CHtiScreenshotServicePlugin::~CHtiScreenshotServicePlugin()

   417     {

   418     HTI_LOG_FUNC_IN( "~CHtiScreenshotServicePlugin" );

   419 

   420     iFontCache.Close();

   421 

   422     delete iScreen;

   423     delete iEncodedBitmap;

   424 

   425     delete iICLHandler;

   426     delete iBitmapEncoder;

   427 

   428     delete iScreenDevice;

   429 

   430     delete iSeriesShot;

   431 

   432     if ( iPreviousBitmap )

   433         delete iPreviousBitmap;

   434 

   435     iWs.Close();

   436     HTI_LOG_FUNC_OUT( "~CHtiScreenshotServicePlugin" );

   437     }

   438 

   439 // ----------------------------------------------------------------------------

   440 // Second phase construction.

   441 void CHtiScreenshotServicePlugin::ConstructL()

   442     {

   443     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::ConstructL" );

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

   445 

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

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

   448 

   449     //InitFontCache();

   450 

   451     iSeriesShot = CSeriesShot::NewL( this );

   452 

   453     iPreviousBitmap = new ( ELeave ) CFbsBitmap;

   454 

   455     //SelectEncoder( KImageTypeBMPUid );

   456     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::ConstructL" );

   457     }

   458 

   459 // ----------------------------------------------------------------------------

   460 TBool CHtiScreenshotServicePlugin::IsBusy()

   461     {

   462     if ( iICLHandler )

   463         {

   464         return iICLHandler->IsActive();

   465         }

   466 

   467     if ( iSeriesShot->IsOngoing() )

   468         {

   469         return ETrue;

   470         }

   471 

   472     return iEncodedBitmap != NULL;

   473     }

   474 

   475 // ----------------------------------------------------------------------------

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

   477     {

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

   479     }

   480 

   481 // ----------------------------------------------------------------------------

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

   483     {

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

   485     }

   486 

   487 // ----------------------------------------------------------------------------

   488 void CHtiScreenshotServicePlugin::SendTextRecgReplyL(

   489                                     const TBool aResult,

   490                                     const TRect& aLocation,

   491                                     const TInt aFontIndex)

   492     {

   493     HTI_LOG_FUNC_IN( "SendTextRecgReplyL" );

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

   495     CleanupStack::PushL( sendMsg );

   496     if ( aResult )

   497         {

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

   499         TUint16 co = aLocation.iTl.iX;

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

   501         co = aLocation.iTl.iY;

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

   503         co = aLocation.iBr.iX;

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

   505         co = aLocation.iBr.iY;

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

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

   508         }

   509     else

   510         {

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

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

   513         }

   514 

   515     User::LeaveIfError( iDispatcher->DispatchOutgoingMessage(

   516                             sendMsg,

   517                             KScreenshotServiceUid) );

   518 

   519     CleanupStack::Pop();

   520     HTI_LOG_FUNC_OUT( "SendTextRecgReplyL" );

   521     }

   522 

   523 // ----------------------------------------------------------------------------

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

   525 {

   526     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::CopyUnicode" );

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

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

   529     aTo.SetLength( len );

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

   531     {

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

   533     }

   534     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::CopyUnicode" );

   535 }

   536 

   537 // ----------------------------------------------------------------------------

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

   539                                         TInt anOffset,

   540                                         TBool aUnicode,

   541                                         TDes& aResult)

   542     {

   543     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::ParseString" );

   544     //validate parameters

   545     //if offset outside the string return empty string

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

   547         {

   548         return anOffset;

   549         }

   550 

   551     TInt len = aRequest[ anOffset ];

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

   553 

   554     if ( len> aResult.MaxLength() )

   555         {

   556         return KErrBadDescriptor;

   557         }

   558 

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

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

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

   562     if ( nextOffset > aRequest.Size() )

   563         {

   564         return KErrArgument;

   565         }

   566 

   567     if ( aUnicode )

   568         {

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

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

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

   572         }

   573     else

   574         {

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

   576         }

   577 

   578     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::ParseString" );

   579     return nextOffset;

   580     }

   581 

   582 // ----------------------------------------------------------------------------

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

   584                     TInt anOffset,

   585                     TBool aUnicode,

   586                     TFontSpec& aResult)

   587     {

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

   589         {

   590         return KErrArgument;

   591         }

   592 

   593     //get font name

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

   595     TInt offset = ParseString( aRequest,

   596                     anOffset,

   597                     aUnicode,

   598                     tn );

   599 

   600     if ( offset > anOffset )

   601         {

   602         HTI_LOG_DES(aResult.iTypeface.iName);

   603         //check that we have valid descr

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

   605             {

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

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

   608             //check style byte

   609             TUint8 style = aRequest[ offset + 2 ];

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

   611 

   612             //stroke bit

   613             if ( style & EHtiFontAttBold )

   614                 {

   615                 aResult.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

   616                 }

   617             else

   618                 {

   619                 aResult.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);

   620                 }

   621             //posture

   622             if ( style & EHtiFontAttItalic )

   623                 {

   624                 aResult.iFontStyle.SetPosture(EPostureItalic);

   625                 }

   626             else

   627                 {

   628                 aResult.iFontStyle.SetPosture(EPostureUpright);

   629                 }

   630             //bitmap glyph type

   631             if ( style & EHtiFontAttNotAA )

   632                 {

   633                 aResult.iFontStyle.SetBitmapType( EMonochromeGlyphBitmap );

   634                 }

   635             else

   636                 {

   637                 aResult.iFontStyle.SetBitmapType( EAntiAliasedGlyphBitmap );

   638                 }

   639             //print position

   640             if ( style & EHtiFontAttPrintPositionFlag )

   641                 {

   642                 TInt printPos = style & EHtiFontAttPrintPositionValue;

   643                 if ( printPos == KHtiFontAttSuperscriptValue )

   644                     {

   645                     aResult.iFontStyle.SetPrintPosition( EPrintPosSuperscript );

   646                     }

   647                 else if ( printPos == KHtiFontAttSubscriptValue )

   648                     {

   649                     aResult.iFontStyle.SetPrintPosition( EPrintPosSubscript );

   650                     }

   651                 }

   652             else

   653                 {

   654                 aResult.iFontStyle.SetPrintPosition( EPrintPosNormal );

   655                 }

   656             return offset + 3;

   657             }

   658         else

   659             {

   660             return KErrArgument;

   661             }

   662         }

   663     else

   664         {

   665         return offset<0?offset:KErrArgument;

   666         }

   667     }

   668 

   669 // ----------------------------------------------------------------------------

   670 void CHtiScreenshotServicePlugin::ProcessTextRcgMessageL(

   671                                     const TDesC8& aMessage)

   672     {

   673     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::ProcessTextRcgMessageL" );

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

   675 

   676     TBuf<0xFF> text;

   677 

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

   679 

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

   681     if ( offset > 1 )

   682         {

   683         HTI_LOG_DES(text);

   684 

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

   686             {

   687             TInt numOfFonts = aMessage[ offset ];

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

   689             iFontCache.Reset();

   690             TInt nextOffset  = offset + 1;

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

   692                 {

   693                 TFontSpec fontSpec;

   694                 nextOffset = ParseFontSpec(aMessage,

   695                                             nextOffset,

   696                                             unicode,

   697                                             fontSpec);

   698                 if ( nextOffset < 0 )

   699                     {

   700                     iDispatcher->DispatchOutgoingErrorMessage(

   701                         nextOffset,

   702                         KErrDescrInvalid,

   703                         KScreenshotServiceUid);

   704                     return;

   705                     }

   706                 else

   707                     {

   708                     iFontCache.Append( fontSpec );

   709                     }

   710                 }

   711 

   712             //parameters parsing END

   713             //get screenshot

   714             TRect empty;

   715             CreateBitmapL( empty, ENone );

   716 

   717             //call text rcg routines

   718             TInt fontIndex;

   719             TRect resultRect;

   720 

   721             //recognize text using fonts from iFontCache

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

   723 

   724             SendTextRecgReplyL( result, resultRect, fontIndex );

   725 

   726             delete iScreen;

   727             iScreen = NULL;

   728             }

   729         else

   730             {

   731             //no fonts data

   732             iDispatcher->DispatchOutgoingErrorMessage(

   733                         KErrArgument,

   734                         KErrDescrInvalid,

   735                         KScreenshotServiceUid);

   736 

   737             }

   738         }

   739     else if ( offset == 1 )

   740         {

   741         //empty text

   742         iDispatcher->DispatchOutgoingErrorMessage(

   743                         KErrArgument,

   744                         KErrDescrInvalid,

   745                         KScreenshotServiceUid);

   746         }

   747     else

   748         {

   749         //error

   750         iDispatcher->DispatchOutgoingErrorMessage(

   751                         offset,

   752                         KErrDescrInvalid,

   753                         KScreenshotServiceUid);

   754         }

   755     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::ProcessTextRcgMessageL" );

   756     }

   757 

   758 // ----------------------------------------------------------------------------

   759 void CHtiScreenshotServicePlugin::ProcessTextBitmapMessageL(

   760                                     const TDesC8& aMessage)

   761     {

   762     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::ProcessTextBitmapMessageL" );

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

   764 

   765     TDisplayMode displayMode = ENone;

   766     //check display

   767     if ( aMessage.Size() > KScreenDisplayOffset )

   768         {

   769         displayMode = (TDisplayMode)aMessage[KScreenDisplayOffset];

   770         if ( displayMode >= EColorLast )

   771             {

   772             iDispatcher->DispatchOutgoingErrorMessage(

   773                             KErrArgument,

   774                             KErrDescrInvalidMode,

   775                             KScreenshotServiceUid);

   776             return;

   777             }

   778         }

   779 

   780     //check mime

   781     TPtrC8 mime;

   782     if ( aMessage[KScreenMIMEOffset] > 0 &&

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

   784         {

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

   786         if ( !IsMIMETypeSupported( mime ) )

   787             {

   788             iDispatcher->DispatchOutgoingErrorMessage(

   789                             KErrArgument,

   790                             KErrDescrMIMENotSupported,

   791                             KScreenshotServiceUid);

   792             return;

   793             }

   794         }

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

   796         {

   797         iDispatcher->DispatchOutgoingErrorMessage(

   798                         KErrArgument,

   799                         KErrDescrInvalidMode,

   800                         KScreenshotServiceUid);

   801         return;

   802         }

   803 

   804     TBuf<0xFF> text;

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

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

   807 

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

   809     if ( offset == preTextOffset )

   810         {

   811         //empty text

   812         iDispatcher->DispatchOutgoingErrorMessage(

   813                         KErrArgument,

   814                         KErrDescrInvalid,

   815                         KScreenshotServiceUid);

   816         }

   817     else if ( offset < preTextOffset )

   818         {

   819         //error

   820         iDispatcher->DispatchOutgoingErrorMessage(

   821                         offset,

   822                         KErrDescrInvalid,

   823                         KScreenshotServiceUid);

   824         }

   825 

   826     HTI_LOG_DES(text);

   827     TFontSpec fontSpec;

   828     offset = ParseFontSpec(aMessage,

   829                             offset,

   830                             unicode,

   831                             fontSpec);

   832     if ( offset < 0 )

   833         {

   834         iDispatcher->DispatchOutgoingErrorMessage(

   835             offset,

   836             KErrDescrInvalid,

   837             KScreenshotServiceUid);

   838 

   839         return;

   840         }

   841 

   842     //check colors

   843     HTI_LOG_TEXT( "check colors" );

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

   845         {

   846         iDispatcher->DispatchOutgoingErrorMessage(

   847             offset,

   848             KErrDescrInvalid,

   849             KScreenshotServiceUid);

   850         return;

   851         }

   852 

   853     //extract colors

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

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

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

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

   858 

   859     //END parsing

   860     //generate and return bitmap

   861     CFont* useFont;

   862 

   863     User::LeaveIfError( iScreenDevice->GetNearestFontToDesignHeightInPixels(

   864                             useFont, fontSpec ) );

   865 

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

   867                                         iScreenDevice->DisplayMode():

   868                                         displayMode;

   869 

   870 

   871     delete iScreen;

   872     iScreen = NULL;

   873     iScreen = CHtiTextRcg::GetTextBitmapL(

   874                             text,

   875                             useFont,

   876                             TRgb( fgColor ),

   877                             TRgb( bgColor ),

   878                             dm );

   879 

   880     iScreenDevice->ReleaseFont( useFont );

   881 

   882     //Encode iBitmap

   883     iCompress = EFalse;

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

   885         {

   886         EncodeBitmapL(); //use default encoder BMP

   887         }

   888     else

   889         {

   890         HTI_LOG_DES( mime );

   891         EncodeBitmapL( mime );

   892         }

   893 

   894     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::ProcessTextBitmapMessageL" );

   895     }

   896 

   897 /*

   898 // ----------------------------------------------------------------------------

   899 TBool CHtiScreenshotServicePlugin::RecognizeTextAllL(

   900                         const TDesC& aText,

   901                         TPoint& aResult)

   902     {

   903     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::RecognizeTextAllL" );

   904 

   905     TSize screenRect = iScreenDevice->SizeInPixels();

   906     TInt nofTF = iScreenDevice->NumTypefaces();

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

   908     TBool returnValue = EFalse;

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

   910         {

   911         TTypefaceSupport tf;

   912         iScreenDevice->TypefaceSupport(tf, i);

   913 

   914         HTI_LOG_DES(tf.iTypeface.iName);

   915 

   916         if ( tf.iIsScalable )

   917             {

   918             //iterate throuh heighes

   919 

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

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

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

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

   924 

   925             HTI_LOG_TEXT( "-----------------------" );

   926 

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

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

   929 

   930             if ( minHeight > maxHeight )

   931                 {

   932                 continue;

   933                 }

   934 

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

   936                 {

   937                 TInt lastFontHeight = 0;

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

   939                     {

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

   941                     fs.iFontStyle.SetBitmapType( EAntiAliasedGlyphBitmap );

   942                     switch ( v )

   943                         {

   944                         case 1:

   945                             {

   946                             fs.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

   947                             HTI_LOG_TEXT( "BOLD" );

   948                             }

   949                             break;

   950                         default:

   951                             {

   952                             HTI_LOG_TEXT( "DEFAULT" );

   953                             }

   954                         }

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

   956 

   957                     CFont* useFont = NULL;

   958 

   959                     iScreenDevice->GetNearestFontToDesignHeightInTwips(useFont, fs);

   960 

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

   962                          screenRect.iWidth < useFont->MaxNormalCharWidthInPixels()

   963                         )

   964                         {

   965                         break;

   966                         }

   967 

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

   969                         {

   970                         continue;

   971                         }

   972 

   973 

   974                     lastFontHeight = useFont->HeightInPixels();

   975 

   976                     returnValue = iTextRcg.RecognizeTextL(

   977                                                 iScreen,

   978                                                 aText,

   979                                                 useFont,

   980                                                 aResult);

   981                     //HTI_LOG_TEXT( "ReleaseFont" );

   982                     iScreenDevice->ReleaseFont(useFont);

   983 

   984                     if ( returnValue )

   985                         {

   986                         HTI_LOG_TEXT( "Found" );

   987                         HTI_LOG_DES( aText );

   988                         HTI_LOG_DES( tf.iTypeface.iName );

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

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

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

   992                         return returnValue;

   993                         }

   994                     }

   995                 }

   996             }

   997         else

   998             {//non scal. font

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

  1000                                                 //not scalable font

  1001 

  1002             CFont* useFont = NULL;

  1003             //HTI_LOG_TEXT( "GetFont" );

  1004             iScreenDevice->GetNearestFontToDesignHeightInTwips( useFont, fs );

  1005 

  1006             returnValue = iTextRcg.RecognizeTextL(

  1007                                         iScreen,

  1008                                         aText,

  1009                                         useFont,

  1010                                         aResult );

  1011             //HTI_LOG_TEXT( "ReleaseFont" );

  1012             iScreenDevice->ReleaseFont( useFont );

  1013 

  1014             if ( returnValue )

  1015                 {

  1016                 HTI_LOG_TEXT( "Found" );

  1017                 HTI_LOG_DES( aText );

  1018                 HTI_LOG_DES(tf.iTypeface.iName );

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

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

  1021                 return returnValue;

  1022                 }

  1023             }

  1024         }

  1025 

  1026     //

  1027 

  1028     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::RecognizeTextAllL" );

  1029     //return returnValue;

  1030     return EFalse;

  1031     }

  1032 */

  1033 

  1034 // ----------------------------------------------------------------------------

  1035 TBool CHtiScreenshotServicePlugin::RecognizeTextL(

  1036                         const TDesC& aText,

  1037                         TRect& aResult,

  1038                         TInt& aFontIndex)

  1039     {

  1040     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::RecognizeTextL" );

  1041 

  1042     TSize screenRect = iScreenDevice->SizeInPixels();

  1043     TInt cacheSize = iFontCache.Count();

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

  1045 

  1046     TBool returnValue = EFalse;

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

  1048         {

  1049         CFont* useFont = NULL;

  1050 

  1051         User::LeaveIfError(iScreenDevice->GetNearestFontToDesignHeightInPixels(

  1052                                 useFont, iFontCache[i] ) );

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

  1054             {

  1055             iTextRcg.SetHint( EHintEdge );

  1056             }

  1057         else

  1058             {

  1059             iTextRcg.SetHint( EHintNone );

  1060             }

  1061 

  1062         //check that font in valid size

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

  1064              screenRect.iWidth < useFont->MaxNormalCharWidthInPixels()

  1065             )

  1066             {

  1067             break;

  1068             }

  1069 

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

  1071                 aResult );

  1072 

  1073         iScreenDevice->ReleaseFont( useFont );

  1074 

  1075         if ( returnValue )

  1076             {

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

  1078             HTI_LOG_DES( aText );

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

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

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

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

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

  1084             aFontIndex = i;

  1085             return returnValue;

  1086             }

  1087         }

  1088 

  1089     HTI_LOG_FUNC_OUT( "CHtiScreenshotServicePlugin::RecognizeTextL" );

  1090     return EFalse;

  1091     }

  1092 

  1093 /*

  1094 TBool CHtiScreenshotServicePlugin::RecognizeTextL(

  1095                         const TDesC& aText,

  1096                         const TDesC& aTypeface,

  1097                         TPoint& aResult)

  1098     {

  1099     HTI_LOG_FUNC_IN( "RecognizeTextL typeface" );

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

  1101     CFont* useFont = NULL;

  1102     TFontSpec fs(aTypeface, 0);

  1103 

  1104     iScreenDevice->GetNearestFontInTwips(useFont, fs);

  1105 

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

  1107 

  1108 HTI_LOG_FUNC_OUT( "RecognizeTextL" );

  1109     return returnValue;

  1110 }

  1111 */

  1112 

  1113 // ----------------------------------------------------------------------------

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

  1115                 THtiMessagePriority /*aPriority*/)

  1116     {

  1117     HTI_LOG_FUNC_IN( "CHtiScreenshotServicePlugin::ProcessMessage");

  1118 

  1119     if ( iICLHandler )

  1120         {

  1121         if ( iICLHandler->IsActive() || iEncodedBitmap)

  1122             {

  1123             User::Leave( KErrInUse );

  1124             }

  1125         }

  1126 

  1127     if ( iSeriesShot->IsOngoing() )

  1128         User::Leave( KErrInUse );

  1129 

  1130     // update the current screen mode

  1131     TPixelsAndRotation currentPixelsAndRotation;

  1132     iScreenDevice->GetScreenModeSizeAndRotation(

  1133             iScreenDevice->CurrentScreenMode(), currentPixelsAndRotation );

  1134     iScreenDevice->SetScreenSizeAndRotation( currentPixelsAndRotation );