htiui/HtiServicePlugins/HtiCameraServicePlugin/src/HtiCameraServicePlugin.cpp
branchRCL_3
changeset 43 48060abbbeaf
parent 42 d40e813b23c0
child 45 b3cee849fa46
equal deleted inserted replaced
42:d40e813b23c0 43:48060abbbeaf
     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:  Implements the ECom plugin for HTI camera
       
    15 *                service.
       
    16 *
       
    17 */
       
    18 
       
    19 
       
    20 
       
    21 // INCLUDE FILES
       
    22 #include <HtiDispatcherInterface.h>
       
    23 #include <HtiLogging.h>
       
    24 
       
    25 
       
    26 #include "HtiCameraServicePlugin.h"
       
    27 
       
    28 // EXTERNAL DATA STRUCTURES
       
    29 
       
    30 // EXTERNAL FUNCTION PROTOTYPES
       
    31 
       
    32 // CONSTANTS
       
    33 
       
    34 // MACROS
       
    35 
       
    36 // LOCAL CONSTANTS AND MACROS
       
    37 const static TUid KCameraServiceUid = { 0x2002EA9E };
       
    38 
       
    39 
       
    40 
       
    41 // NOTE: Max length for error description is defined
       
    42 // in HtiDispatcherInterface.h (currently 118).
       
    43 
       
    44 _LIT8( KErrorNoCommand, "ERROR: No command given" );
       
    45 _LIT8( KErrorUnknownCmd, "ERROR: Unknown Camera Service command" );
       
    46 _LIT8( KErrorInitFailed, "ERROR: Failed to init");
       
    47 _LIT8( KErrorUninitialized, "ERROR: Uninitialized");
       
    48 _LIT8( KErrInvalidateParameters, "ERROR: Invalidate parameters");
       
    49 _LIT8( KErrQualityLevel, "ERROR: Invalidate quality level");
       
    50 _LIT8( KErrorPrepareVideoRecordingFailed, "ERROR: Prepare video recording failed");
       
    51 _LIT8( KErrorStartVideoRecordingFailed, "ERROR: Start video recording failed");
       
    52 _LIT8( KErrorPausingVideoRecordingFailed, "ERROR: Pausing video recording failed");
       
    53 _LIT8( KErrorResumeVideoRecordingFailed, "ERROR: Resume video recording failed");
       
    54 _LIT8( KErrorStopVideoRecordingFailed, "ERROR: Stop video recording failed");
       
    55 _LIT8( KErrorSetZoomModeFailed, "ERROR: Set zoom mode failed");
       
    56 _LIT8( KErrorSetZoomValueFailed, "ERROR: Set zoom value failed");
       
    57 
       
    58 // MODULE DATA STRUCTURES
       
    59 
       
    60 // LOCAL FUNCTION PROTOTYPES
       
    61 
       
    62 // FORWARD DECLARATIONS
       
    63 
       
    64 // ============================= LOCAL FUNCTIONS ===============================
       
    65 
       
    66 // ============================ MEMBER FUNCTIONS ===============================
       
    67 
       
    68 // -----------------------------------------------------------------------------
       
    69 // CHtiCameraServicePlugin::CHtiCameraServicePlugin
       
    70 // C++ default constructor can NOT contain any code, that might leave.
       
    71 // -----------------------------------------------------------------------------
       
    72 //
       
    73 CHtiCameraServicePlugin::CHtiCameraServicePlugin():iIsBusy(EFalse), iError(0),
       
    74         iVideoRecordingEngine(NULL), iWaiter(NULL)
       
    75     {
       
    76     }
       
    77 
       
    78 
       
    79 // -----------------------------------------------------------------------------
       
    80 // CHtiCameraServicePlugin::ConstructL
       
    81 // Symbian 2nd phase constructor can leave.
       
    82 // -----------------------------------------------------------------------------
       
    83 //
       
    84 void CHtiCameraServicePlugin::ConstructL()
       
    85     {
       
    86     HTI_LOG_TEXT( "CHtiCameraServicePlugin::ConstructL" );
       
    87     iWaiter = new ( ELeave ) CActiveSchedulerWait;
       
    88     }
       
    89 
       
    90 
       
    91 // -----------------------------------------------------------------------------
       
    92 // CHtiCameraServicePlugin::NewL
       
    93 // Two-phased constructor.
       
    94 // -----------------------------------------------------------------------------
       
    95 //
       
    96 CHtiCameraServicePlugin* CHtiCameraServicePlugin::NewL()
       
    97     {
       
    98     CHtiCameraServicePlugin* self = new (ELeave) CHtiCameraServicePlugin;
       
    99     CleanupStack::PushL( self );
       
   100     self->ConstructL();
       
   101     CleanupStack::Pop();
       
   102     return self;
       
   103     }
       
   104 
       
   105 
       
   106 // Destructor
       
   107 CHtiCameraServicePlugin::~CHtiCameraServicePlugin()
       
   108     {
       
   109     if(iVideoRecordingEngine)
       
   110         {
       
   111         delete iVideoRecordingEngine;
       
   112         iVideoRecordingEngine = NULL;
       
   113         }
       
   114     
       
   115     delete iWaiter;
       
   116     iWaiter = NULL;
       
   117     }
       
   118 
       
   119 
       
   120 // -----------------------------------------------------------------------------
       
   121 // CHtiCameraServicePlugin::ProcessMessageL
       
   122 // -----------------------------------------------------------------------------
       
   123 //
       
   124 void CHtiCameraServicePlugin::ProcessMessageL( const TDesC8& aMessage,
       
   125                                         THtiMessagePriority /*aPriority*/ )
       
   126     {
       
   127     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::ProcessMessageL" );
       
   128     HTI_LOG_FORMAT( "Message length = %d", aMessage.Length() );
       
   129 
       
   130     if ( iIsBusy )
       
   131         {
       
   132         HTI_LOG_TEXT( "Plugin is busy - leaving" );
       
   133         User::Leave( KErrInUse );
       
   134         }
       
   135 
       
   136     // Will be set to EFalse in the SendResponseMsg or SendErrorResponseMsg
       
   137     // methods when the response has been successfully sent and the plugin is
       
   138     // ready for next message.
       
   139     iIsBusy = ETrue;
       
   140 
       
   141     if ( aMessage.Length() < 1 )
       
   142         {
       
   143         SendErrorMessageL( KErrArgument, KErrorNoCommand );
       
   144         return;
       
   145         }
       
   146     
       
   147     TUint8 command = aMessage.Ptr()[0];
       
   148     TInt err = KErrNone;
       
   149 
       
   150     switch (command)
       
   151         {
       
   152         case ECmdInitialize:
       
   153             TRAP(err, HandleInitializeCmdL(aMessage.Right( aMessage.Length() - 1 )));
       
   154             break;
       
   155         case ECmdUninitialize:
       
   156             TRAP(err, HandleUninitializeCmdL(aMessage.Right( aMessage.Length() - 1 )));
       
   157             break;
       
   158         case ECmdPrepareVideoRecording:
       
   159             TRAP(err, HandlePrepareVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));
       
   160             break;
       
   161         case ECmdStartVideoRecording:
       
   162             TRAP(err, HandleStartVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));
       
   163             break;
       
   164         case ECmdPausingVideoRecording:
       
   165             TRAP(err, HandlePausingVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));
       
   166             break;
       
   167         case ECmdResumeVideoRecording:
       
   168             TRAP(err, HandleResumeVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));
       
   169             break;
       
   170         case ECmdStopVideoRecording:
       
   171             TRAP(err, HandleStopVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));
       
   172             break;
       
   173         case ECmdCloseVideoRecording:
       
   174             TRAP(err, HandleCloseVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));
       
   175             break;
       
   176         case ECmdGetZoom:
       
   177             TRAP(err, HandleGetZoomCmdL(aMessage.Right( aMessage.Length() - 1 )));
       
   178             break;
       
   179         case ECmdSetZoom:
       
   180             TRAP(err, HandleSetZoomCmdL(aMessage.Right( aMessage.Length() - 1 )));
       
   181             break;
       
   182         default:
       
   183             TRAP(err, SendErrorMessageL(KErrArgument, KErrorUnknownCmd));
       
   184             break;
       
   185         }
       
   186     
       
   187     if(err != KErrNone)
       
   188         {
       
   189         iIsBusy = EFalse;
       
   190         User::Leave( err );
       
   191         }
       
   192 
       
   193     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::ProcessMessageL" );
       
   194     }
       
   195 
       
   196 void CHtiCameraServicePlugin::HandleInitializeCmdL( const TDesC8& aData )
       
   197     {
       
   198     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleInitializeCmdL" );
       
   199     if(aData.Length() != 0)
       
   200         {
       
   201         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   202         return;
       
   203         }
       
   204     
       
   205     HTI_LOG_TEXT("Initializes Camera Application Engine");
       
   206     if(iVideoRecordingEngine)
       
   207         {
       
   208         delete iVideoRecordingEngine;
       
   209         iVideoRecordingEngine = NULL;
       
   210         }
       
   211     
       
   212     iVideoRecordingEngine = CEngineVideoRecording::NewL(*this, 0);
       
   213     iVideoRecordingEngine->InitL();
       
   214     iWaiter->Start();
       
   215     if(iError != KErrNone)
       
   216         {
       
   217         SendErrorMessageL(iError, KErrorInitFailed);
       
   218         }
       
   219     else
       
   220         {
       
   221         HTI_LOG_TEXT("Initializes video recording");
       
   222         iVideoRecordingEngine->InitVideoRecorderL();
       
   223         
       
   224         SendOkMsgL(KNullDesC8);
       
   225         }
       
   226 
       
   227     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleInitializeCmdL" );
       
   228     }
       
   229 
       
   230 void CHtiCameraServicePlugin::HandleUninitializeCmdL(const TDesC8& aData)
       
   231     {
       
   232     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleUninitializeCmdL" );
       
   233     if(aData.Length() != 0)
       
   234         {
       
   235         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   236         return;
       
   237         }
       
   238     
       
   239     if(iVideoRecordingEngine == NULL)
       
   240         {
       
   241         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
       
   242         return;
       
   243         }
       
   244     
       
   245     delete iVideoRecordingEngine;
       
   246     iVideoRecordingEngine = NULL;
       
   247     
       
   248     SendOkMsgL(KNullDesC8);
       
   249     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleUninitializeCmdL" );
       
   250     }
       
   251 
       
   252 void CHtiCameraServicePlugin::HandlePrepareVideoRecordingCmdL( const TDesC8& aData )
       
   253     {
       
   254     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandlePrepareVideoRecordingCmdL" );
       
   255     if(aData.Length() < 2 || aData[1] != aData.Length() -2)
       
   256         {
       
   257         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   258         return;
       
   259         }
       
   260     
       
   261     if(iVideoRecordingEngine == NULL)
       
   262         {
       
   263         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
       
   264         return;
       
   265         }
       
   266     
       
   267     TInt qualityLevelIndex = aData[0];
       
   268     if(qualityLevelIndex < 0 || qualityLevelIndex > iVideoRecordingEngine->VideoQualityCount() -1)
       
   269         {
       
   270         SendErrorMessageL(KErrOverflow, KErrQualityLevel);
       
   271         return;
       
   272         }
       
   273     
       
   274     TBuf<255> filePath;
       
   275     TInt nextOffset = ParseString( aData, 1, filePath );
       
   276     if ( filePath.Length() < 1 || nextOffset < 0 )
       
   277         {
       
   278         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   279         return;
       
   280         }
       
   281     
       
   282     HTI_LOG_FORMAT("Set video recording file name: %S", &filePath);
       
   283     iVideoRecordingEngine->SetVideoRecordingFileNameL(filePath);
       
   284     
       
   285     HTI_LOG_FORMAT("Prepare video recording with quality level index: %d", qualityLevelIndex);
       
   286     iVideoRecordingEngine->PrepareVideoRecordingL(qualityLevelIndex);
       
   287     
       
   288     iWaiter->Start();
       
   289     if(iError != KErrNone)
       
   290         {
       
   291         SendErrorMessageL(iError, KErrorPrepareVideoRecordingFailed);
       
   292         }
       
   293     else
       
   294         {
       
   295         SendOkMsgL(KNullDesC8);
       
   296         }
       
   297     
       
   298      HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandlePrepareVideoRecordingCmdL" );
       
   299     }
       
   300 
       
   301 void CHtiCameraServicePlugin::HandleStartVideoRecordingCmdL( const TDesC8& aData )
       
   302     {
       
   303     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleStartVideoRecordingCmdL" );
       
   304     if(aData.Length() != 0)
       
   305         {
       
   306         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   307         return;
       
   308         }
       
   309     
       
   310     if(iVideoRecordingEngine == NULL)
       
   311         {
       
   312         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
       
   313         return;
       
   314         }
       
   315     
       
   316     HTI_LOG_TEXT("Start video recording...");
       
   317     iVideoRecordingEngine->StartVideoRecording();
       
   318     
       
   319     if(iError != KErrNone)
       
   320         {
       
   321         SendErrorMessageL(iError, KErrorStartVideoRecordingFailed);
       
   322         }
       
   323     else
       
   324         {
       
   325         SendOkMsgL(KNullDesC8);
       
   326         }
       
   327 
       
   328     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleStartVideoRecordingCmdL" );
       
   329     }
       
   330 
       
   331 void CHtiCameraServicePlugin::HandlePausingVideoRecordingCmdL( const TDesC8& aData )
       
   332     {
       
   333     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandlePausingVideoRecordingCmdL" );
       
   334     if(aData.Length() != 0)
       
   335         {
       
   336         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   337         return;
       
   338         }
       
   339     
       
   340     if(iVideoRecordingEngine == NULL)
       
   341         {
       
   342         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
       
   343         return;
       
   344         }
       
   345     
       
   346     HTI_LOG_TEXT("Pausing video recording");
       
   347     iVideoRecordingEngine->PauseVideoRecording();
       
   348     if(iError != KErrNone)
       
   349         {
       
   350         SendErrorMessageL(iError, KErrorPausingVideoRecordingFailed);
       
   351         }
       
   352     else
       
   353         {
       
   354         SendOkMsgL(KNullDesC8);
       
   355         }
       
   356     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandlePausingVideoRecordingCmdL" );
       
   357     }
       
   358 
       
   359 void CHtiCameraServicePlugin::HandleResumeVideoRecordingCmdL( const TDesC8& aData )
       
   360     {
       
   361     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleResumeVideoRecordingCmdL" );
       
   362     if(aData.Length() != 0)
       
   363         {
       
   364         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   365         return;
       
   366         }
       
   367     
       
   368     if(iVideoRecordingEngine == NULL)
       
   369         {
       
   370         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
       
   371         return;
       
   372         }
       
   373     
       
   374     HTI_LOG_TEXT("Resume video recording...");
       
   375     iVideoRecordingEngine->ResumeVideoRecording();
       
   376     
       
   377     if(iError != KErrNone)
       
   378         {
       
   379         SendErrorMessageL(iError, KErrorResumeVideoRecordingFailed);
       
   380         }
       
   381     else
       
   382         {
       
   383         SendOkMsgL(KNullDesC8);
       
   384         }
       
   385     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleResumeVideoRecordingCmdL" );
       
   386     }
       
   387 
       
   388 void CHtiCameraServicePlugin::HandleStopVideoRecordingCmdL( const TDesC8& aData )    
       
   389     {
       
   390     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleStopVideoRecordingCmdL" );
       
   391     if(aData.Length() != 0)
       
   392         {
       
   393         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   394         return;
       
   395         }
       
   396     
       
   397     if(iVideoRecordingEngine == NULL)
       
   398         {
       
   399         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
       
   400         return;
       
   401         }
       
   402     
       
   403     HTI_LOG_TEXT("Stop video recording");
       
   404     iVideoRecordingEngine->StopVideoRecording();
       
   405     if(iError != KErrNone)
       
   406         {
       
   407         SendErrorMessageL(iError, KErrorStopVideoRecordingFailed);
       
   408         }
       
   409     else
       
   410         {
       
   411         SendOkMsgL(KNullDesC8);
       
   412         }
       
   413     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleStopVideoRecordingCmdL" );
       
   414     }
       
   415 
       
   416 void CHtiCameraServicePlugin::HandleCloseVideoRecordingCmdL( const TDesC8& aData )
       
   417     {
       
   418     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleCloseVideoRecordingCmdL" );
       
   419     if(aData.Length() != 0)
       
   420         {
       
   421         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   422         return;
       
   423         }
       
   424     
       
   425     if(iVideoRecordingEngine == NULL)
       
   426         {
       
   427         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
       
   428         return;
       
   429         }
       
   430     
       
   431     HTI_LOG_TEXT("Close video recording");
       
   432     iVideoRecordingEngine->CloseVideoRecording();
       
   433     SendOkMsgL(KNullDesC8);
       
   434     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleCloseVideoRecordingCmdL" );
       
   435     }
       
   436 
       
   437 void CHtiCameraServicePlugin::HandleGetZoomCmdL( const TDesC8& aData )
       
   438     {
       
   439     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleGetZoomCmdL" );
       
   440     if(aData.Length() != 0)
       
   441         {
       
   442         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   443         return;
       
   444         }
       
   445     
       
   446     if(iVideoRecordingEngine == NULL)
       
   447         {
       
   448         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
       
   449         return;
       
   450         }
       
   451     
       
   452     TUint8 zoomMode = (TUint8)iVideoRecordingEngine->ZoomMode();
       
   453     HTI_LOG_FORMAT("Current zoom mode: %d", zoomMode);
       
   454     
       
   455     TUint32 zoomValue = iVideoRecordingEngine->ZoomValue();
       
   456     HTI_LOG_FORMAT("Current zoom value: %d", zoomValue);
       
   457     
       
   458     TUint32 zoomMinValue = iVideoRecordingEngine->MinZoomValue();
       
   459     HTI_LOG_FORMAT("Min zoom value: %d", zoomMinValue);
       
   460     
       
   461     TUint32 zoomMaxValue = iVideoRecordingEngine->MaxZoomValue();
       
   462     HTI_LOG_FORMAT("Max zoom value: %d", zoomMaxValue);
       
   463     
       
   464     TBuf8<13> buf;
       
   465     buf.Append(zoomMode);
       
   466     buf.Append((TUint8*)&zoomValue, 4);
       
   467     buf.Append((TUint8*)&zoomMinValue, 4);
       
   468     buf.Append((TUint8*)&zoomMaxValue, 4);
       
   469     SendOkMsgL( buf );
       
   470 
       
   471     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleGetZoomCmdL" );
       
   472     }
       
   473 
       
   474 void CHtiCameraServicePlugin::HandleSetZoomCmdL( const TDesC8& aData )
       
   475     {
       
   476     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleSetZoomCmdL" );
       
   477     if(aData.Length() != 5)
       
   478         {
       
   479         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   480         return;
       
   481         }
       
   482     
       
   483     if(iVideoRecordingEngine == NULL)
       
   484         {
       
   485         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
       
   486         return;
       
   487         }
       
   488     
       
   489     CEngineVideoRecording::TZoomMode zoomMode = (CEngineVideoRecording::TZoomMode)aData[0];
       
   490     HTI_LOG_FORMAT("Set zoom mode: %d", zoomMode);
       
   491     TRAPD(err, iVideoRecordingEngine->SetZoomModeL(zoomMode));
       
   492     if(err != KErrNone)
       
   493         {
       
   494         SendErrorMessageL(err, KErrorSetZoomModeFailed);
       
   495         }
       
   496     else
       
   497         {
       
   498         TInt value = aData[1] + ( aData[2] << 8 )
       
   499                 + ( aData[3] << 16 )
       
   500                 + ( aData[4] << 24 );
       
   501         HTI_LOG_FORMAT("Set zoom value: %d", value);
       
   502         TRAPD(err, iVideoRecordingEngine->SetZoomValueL(value));
       
   503         if(err != KErrNone)
       
   504             {
       
   505             SendErrorMessageL(err, KErrorSetZoomValueFailed);
       
   506             }
       
   507         else
       
   508             {
       
   509             SendOkMsgL(KNullDesC8);
       
   510             }
       
   511         }
       
   512     
       
   513     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleSetZoomCmdL" );
       
   514     }
       
   515 
       
   516 
       
   517 // -----------------------------------------------------------------------------
       
   518 // CHtiCameraServicePlugin::IsBusy
       
   519 // -----------------------------------------------------------------------------
       
   520 //
       
   521 TBool CHtiCameraServicePlugin::IsBusy()
       
   522     {
       
   523     return iIsBusy;
       
   524     }
       
   525 
       
   526 
       
   527 // ----------------------------------------------------------------------------
       
   528 void CHtiCameraServicePlugin::SendOkMsgL( const TDesC8& aData )
       
   529     {
       
   530     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::SendOkMsgL: Starting" );
       
   531 
       
   532     User::LeaveIfNull( iDispatcher );
       
   533 
       
   534     HBufC8* temp = HBufC8::NewL( aData.Length() + 1 );
       
   535     TPtr8 response = temp->Des();
       
   536     response.Append( ( TChar ) EResultOk );
       
   537     response.Append( aData );
       
   538     User::LeaveIfError( iDispatcher->DispatchOutgoingMessage(
       
   539         temp, KCameraServiceUid ) );
       
   540     iIsBusy = EFalse;
       
   541     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::SendOkMsgL: Done" );
       
   542     }
       
   543 
       
   544 // ----------------------------------------------------------------------------
       
   545 void CHtiCameraServicePlugin::SendErrorMessageL( TInt aError, const TDesC8& aDescription )
       
   546     {
       
   547     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::SendErrorMessageL: Starting" );
       
   548     User::LeaveIfNull( iDispatcher );
       
   549     User::LeaveIfError( iDispatcher->DispatchOutgoingErrorMessage(
       
   550         aError, aDescription, KCameraServiceUid ) );
       
   551     iIsBusy = EFalse;
       
   552     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::SendErrorMessageL: Done" );
       
   553     }
       
   554 
       
   555 TInt CHtiCameraServicePlugin::ParseString( const TDesC8& aRequest,
       
   556                                           TInt aOffset,
       
   557                                           TDes& aResult )
       
   558     {
       
   559     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::ParseString" );
       
   560 
       
   561     // If offset outside the string return empty string
       
   562     if ( aOffset >= aRequest.Size() )
       
   563         {
       
   564         return aOffset;
       
   565         }
       
   566 
       
   567     TInt length = aRequest[aOffset];
       
   568     HTI_LOG_FORMAT( "String length = %d", length );
       
   569 
       
   570     // If length is zero return empty string
       
   571     if ( length < 1 )
       
   572         {
       
   573         return aOffset + 1;
       
   574         }
       
   575 
       
   576     if ( length > aResult.MaxLength() )
       
   577         {
       
   578         return KErrBadDescriptor;
       
   579         }
       
   580 
       
   581     TInt nextOffset = length + aOffset + 1;
       
   582     HTI_LOG_FORMAT( "Next offset = %d", nextOffset );
       
   583     HTI_LOG_FORMAT( "Request size = %d", aRequest.Size() );
       
   584 
       
   585     if ( nextOffset > aRequest.Size() )
       
   586         {
       
   587         return KErrArgument;
       
   588         }
       
   589 
       
   590     aResult.Copy( aRequest.Mid( aOffset + 1, length ) );
       
   591 
       
   592     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::ParseString" );
       
   593     return nextOffset;
       
   594     }
       
   595 
       
   596 void CHtiCameraServicePlugin::MevroInitComplete( TInt aError )
       
   597     {
       
   598     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroInitComplete" );
       
   599     HTI_LOG_FORMAT("aError = %d", aError);
       
   600     iError = aError; 
       
   601     iWaiter->AsyncStop();
       
   602     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroInitComplete" );
       
   603     }
       
   604 
       
   605 void CHtiCameraServicePlugin::MevroVideoPrepareComplete(TInt aError)
       
   606     {
       
   607     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroVideoPrepareComplete" );
       
   608     HTI_LOG_FORMAT("aError = %d", aError);
       
   609     iError = aError;
       
   610     iWaiter->AsyncStop();
       
   611     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroVideoPrepareComplete" );
       
   612     }
       
   613 
       
   614 void CHtiCameraServicePlugin::MevroVideoRecordingOn(TInt aError)
       
   615     {
       
   616     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroVideoRecordingOn" );
       
   617     HTI_LOG_FORMAT("aError = %d", aError);
       
   618     iError = aError;
       
   619     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroVideoRecordingOn" );
       
   620     }
       
   621 
       
   622 void CHtiCameraServicePlugin::MevroVideoRecordingPaused(TInt aError)
       
   623     {
       
   624     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroVideoRecordingPaused" );
       
   625     HTI_LOG_FORMAT("aError = %d", aError);
       
   626     iError = aError;
       
   627     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroVideoRecordingPaused" );
       
   628     }
       
   629 
       
   630 void CHtiCameraServicePlugin::MevroVideoRecordingComplete(TInt aError)
       
   631     {
       
   632     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroVideoRecordingComplete" );
       
   633     HTI_LOG_FORMAT("aError = %d", aError);
       
   634     iError = aError;
       
   635     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroVideoRecordingComplete" );
       
   636     }
       
   637 //  End of File