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( KErrInvalidateParameters, "ERROR: Invalidate parameters");

    48 _LIT8( KErrQualityLevel, "ERROR: Invalidate quality level");

    49 _LIT8( KErrorPrepareVideoRecordingFailed, "ERROR: Prepare video recording failed");

    50 _LIT8( KErrorStartVideoRecordingFailed, "ERROR: Start video recording failed");

    51 _LIT8( KErrorPausingVideoRecordingFailed, "ERROR: Pausing video recording failed");

    52 _LIT8( KErrorResumeVideoRecordingFailed, "ERROR: Resume video recording failed");

    53 _LIT8( KErrorStopVideoRecordingFailed, "ERROR: Stop video recording failed");

    54 _LIT8( KErrorSetZoomModeFailed, "ERROR: Set zoom mode failed");

    55 _LIT8( KErrorSetZoomValueFailed, "ERROR: Set zoom value failed");

    56 

    57 // MODULE DATA STRUCTURES

    58 

    59 // LOCAL FUNCTION PROTOTYPES

    60 

    61 // FORWARD DECLARATIONS

    62 

    63 // ============================= LOCAL FUNCTIONS ===============================

    64 

    65 // ============================ MEMBER FUNCTIONS ===============================

    66 

    67 // -----------------------------------------------------------------------------

    68 // CHtiCameraServicePlugin::CHtiCameraServicePlugin

    69 // C++ default constructor can NOT contain any code, that might leave.

    70 // -----------------------------------------------------------------------------

    71 //

    72 CHtiCameraServicePlugin::CHtiCameraServicePlugin():iIsBusy(EFalse), iError(0),

    73         iVideoRecordingEngine(NULL), iWaiter(NULL)

    74     {

    75     }

    76 

    77 

    78 // -----------------------------------------------------------------------------

    79 // CHtiCameraServicePlugin::ConstructL

    80 // Symbian 2nd phase constructor can leave.

    81 // -----------------------------------------------------------------------------

    82 //

    83 void CHtiCameraServicePlugin::ConstructL()

    84     {

    85     HTI_LOG_TEXT( "CHtiCameraServicePlugin::ConstructL" );

    86     iVideoRecordingEngine = CEngineVideoRecording::NewL(*this, 0);

    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     delete iVideoRecordingEngine;

   110     iVideoRecordingEngine = NULL;

   111     

   112     delete iWaiter;

   113     iWaiter = NULL;

   114     }

   115 

   116 

   117 // -----------------------------------------------------------------------------

   118 // CHtiCameraServicePlugin::ProcessMessageL

   119 // -----------------------------------------------------------------------------

   120 //

   121 void CHtiCameraServicePlugin::ProcessMessageL( const TDesC8& aMessage,

   122                                         THtiMessagePriority /*aPriority*/ )

   123     {

   124     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::ProcessMessageL" );

   125     HTI_LOG_FORMAT( "Message length = %d", aMessage.Length() );

   126 

   127     if ( iIsBusy )

   128         {

   129         HTI_LOG_TEXT( "Plugin is busy - leaving" );

   130         User::Leave( KErrInUse );

   131         }

   132 

   133     // Will be set to EFalse in the SendResponseMsg or SendErrorResponseMsg

   134     // methods when the response has been successfully sent and the plugin is

   135     // ready for next message.

   136     iIsBusy = ETrue;

   137 

   138     if ( aMessage.Length() < 1 )

   139         {

   140         SendErrorMessageL( KErrArgument, KErrorNoCommand );

   141         return;

   142         }

   143     

   144     TUint8 command = aMessage.Ptr()[0];

   145     TInt err = KErrNone;

   146 

   147     switch (command)

   148         {

   149         case ECmdInit:

   150             TRAP(err, HandleInitCmdL(aMessage.Right( aMessage.Length() - 1 )));

   151             break;

   152         case ECmdPrepareVideoRecording:

   153             TRAP(err, HandlePrepareVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));

   154             break;

   155         case ECmdStartVideoRecording:

   156             TRAP(err, HandleStartVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));

   157             break;

   158         case ECmdPausingVideoRecording:

   159             TRAP(err, HandlePausingVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));

   160             break;

   161         case ECmdResumeVideoRecording:

   162             TRAP(err, HandleResumeVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));

   163             break;

   164         case ECmdStopVideoRecording:

   165             TRAP(err, HandleStopVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));

   166             break;

   167         case ECmdCloseVideoRecording:

   168             TRAP(err, HandleCloseVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));

   169             break;

   170         case ECmdGetZoom:

   171             TRAP(err, HandleGetZoomCmdL(aMessage.Right( aMessage.Length() - 1 )));

   172             break;

   173         case ECmdSetZoom:

   174             TRAP(err, HandleSetZoomCmdL(aMessage.Right( aMessage.Length() - 1 )));

   175             break;

   176         default:

   177             TRAP(err, SendErrorMessageL(KErrArgument, KErrorUnknownCmd));

   178             break;

   179         }

   180     

   181     if(err != KErrNone)

   182         {

   183         iIsBusy = EFalse;

   184         User::Leave( err );

   185         }

   186 

   187     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::ProcessMessageL" );

   188     }

   189 

   190 void CHtiCameraServicePlugin::HandleInitCmdL( const TDesC8& aData )

   191     {

   192     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleInitCmdL" );

   193     if(aData.Length() != 0)

   194         {

   195         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);

   196         return;

   197         }

   198     

   199     HTI_LOG_TEXT("Initializes Camera Application Engine");

   200     iVideoRecordingEngine->InitL();

   201     iWaiter->Start();

   202     if(iError != KErrNone)

   203         {

   204         SendErrorMessageL(iError, KErrorInitFailed);

   205         }

   206     else

   207         {

   208         HTI_LOG_TEXT("Initializes video recording");

   209         iVideoRecordingEngine->InitVideoRecorderL();

   210         

   211         SendOkMsgL(KNullDesC8);

   212         }

   213 

   214     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleInitCmdL" );

   215     }

   216 

   217 

   218 void CHtiCameraServicePlugin::HandlePrepareVideoRecordingCmdL( const TDesC8& aData )

   219     {

   220     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandlePrepareVideoRecordingCmdL" );

   221     if(aData.Length() < 2 || aData[1] != aData.Length() -2)

   222         {

   223         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);

   224         return;

   225         }

   226     

   227     TInt qualityLevelIndex = aData[0];

   228     if(qualityLevelIndex < 0 || qualityLevelIndex > iVideoRecordingEngine->VideoQualityCount() -1)

   229         {

   230         SendErrorMessageL(KErrOverflow, KErrQualityLevel);

   231         return;

   232         }

   233     

   234     TBuf<255> filePath;

   235     TInt nextOffset = ParseString( aData, 1, filePath );

   236     if ( filePath.Length() < 1 || nextOffset < 0 )

   237         {

   238         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);

   239         return;

   240         }

   241     

   242     HTI_LOG_FORMAT("Set video recording file name: %S", &filePath);

   243     iVideoRecordingEngine->SetVideoRecordingFileNameL(filePath);

   244     

   245     HTI_LOG_FORMAT("Prepare video recording with quality level index: %d", qualityLevelIndex);

   246     iVideoRecordingEngine->PrepareVideoRecordingL(qualityLevelIndex);

   247     

   248     iWaiter->Start();

   249     if(iError != KErrNone)

   250         {

   251         SendErrorMessageL(iError, KErrorPrepareVideoRecordingFailed);

   252         }

   253     else

   254         {

   255         SendOkMsgL(KNullDesC8);

   256         }

   257     

   258      HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandlePrepareVideoRecordingCmdL" );

   259     }

   260 

   261 void CHtiCameraServicePlugin::HandleStartVideoRecordingCmdL( const TDesC8& aData )

   262     {

   263     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleStartVideoRecordingCmdL" );

   264     if(aData.Length() != 0)

   265         {

   266         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);

   267         return;

   268         }

   269     

   270     HTI_LOG_TEXT("Start video recording...");

   271     iVideoRecordingEngine->StartVideoRecording();

   272     

   273     if(iError != KErrNone)

   274         {

   275         SendErrorMessageL(iError, KErrorStartVideoRecordingFailed);

   276         }

   277     else

   278         {

   279         SendOkMsgL(KNullDesC8);

   280         }

   281 

   282     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleStartVideoRecordingCmdL" );

   283     }

   284 

   285 void CHtiCameraServicePlugin::HandlePausingVideoRecordingCmdL( const TDesC8& aData )

   286     {

   287     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandlePausingVideoRecordingCmdL" );

   288     if(aData.Length() != 0)

   289         {

   290         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);

   291         return;

   292         }

   293     

   294     HTI_LOG_TEXT("Pausing video recording");

   295     iVideoRecordingEngine->PauseVideoRecording();

   296     if(iError != KErrNone)

   297         {

   298         SendErrorMessageL(iError, KErrorPausingVideoRecordingFailed);

   299         }

   300     else

   301         {

   302         SendOkMsgL(KNullDesC8);

   303         }

   304     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandlePausingVideoRecordingCmdL" );

   305     }

   306 

   307 void CHtiCameraServicePlugin::HandleResumeVideoRecordingCmdL( const TDesC8& aData )

   308     {

   309     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleResumeVideoRecordingCmdL" );

   310     if(aData.Length() != 0)

   311         {

   312         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);

   313         return;

   314         }

   315     

   316     HTI_LOG_TEXT("Resume video recording...");

   317     iVideoRecordingEngine->ResumeVideoRecording();

   318     

   319     if(iError != KErrNone)

   320         {

   321         SendErrorMessageL(iError, KErrorResumeVideoRecordingFailed);

   322         }

   323     else

   324         {

   325         SendOkMsgL(KNullDesC8);

   326         }

   327     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleResumeVideoRecordingCmdL" );

   328     }

   329 

   330 void CHtiCameraServicePlugin::HandleStopVideoRecordingCmdL( const TDesC8& aData )    

   331     {

   332     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleStopVideoRecordingCmdL" );

   333     if(aData.Length() != 0)

   334         {

   335         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);

   336         return;

   337         }

   338     

   339     HTI_LOG_TEXT("Stop video recording");

   340     iVideoRecordingEngine->StopVideoRecording();

   341     if(iError != KErrNone)

   342         {

   343         SendErrorMessageL(iError, KErrorStopVideoRecordingFailed);

   344         }

   345     else

   346         {

   347         SendOkMsgL(KNullDesC8);

   348         }

   349     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleStopVideoRecordingCmdL" );

   350     }

   351 

   352 void CHtiCameraServicePlugin::HandleCloseVideoRecordingCmdL( const TDesC8& aData )

   353     {

   354     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleCloseVideoRecordingCmdL" );

   355     if(aData.Length() != 0)

   356         {

   357         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);

   358         return;

   359         }

   360     

   361     HTI_LOG_TEXT("Close video recording");

   362     iVideoRecordingEngine->CloseVideoRecording();

   363     SendOkMsgL(KNullDesC8);

   364     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleCloseVideoRecordingCmdL" );

   365     }

   366 

   367 void CHtiCameraServicePlugin::HandleGetZoomCmdL( const TDesC8& aData )

   368     {

   369     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleGetZoomCmdL" );

   370     if(aData.Length() != 0)

   371         {

   372         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);

   373         return;

   374         }

   375     

   376     TUint8 zoomMode = (TUint8)iVideoRecordingEngine->ZoomMode();

   377     HTI_LOG_FORMAT("Current zoom mode: %d", zoomMode);

   378     

   379     TUint32 zoomValue = iVideoRecordingEngine->ZoomValue();

   380     HTI_LOG_FORMAT("Current zoom value: %d", zoomValue);

   381     

   382     TUint32 zoomMinValue = iVideoRecordingEngine->MinZoomValue();

   383     HTI_LOG_FORMAT("Min zoom value: %d", zoomMinValue);

   384     

   385     TUint32 zoomMaxValue = iVideoRecordingEngine->MaxZoomValue();

   386     HTI_LOG_FORMAT("Max zoom value: %d", zoomMaxValue);

   387     

   388     TBuf8<13> buf;

   389     buf.Append(zoomMode);

   390     buf.Append((TUint8*)&zoomValue, 4);

   391     buf.Append((TUint8*)&zoomMinValue, 4);

   392     buf.Append((TUint8*)&zoomMaxValue, 4);

   393     SendOkMsgL( buf );

   394 

   395     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleGetZoomCmdL" );

   396     }

   397 

   398 void CHtiCameraServicePlugin::HandleSetZoomCmdL( const TDesC8& aData )

   399     {

   400     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleSetZoomCmdL" );

   401     if(aData.Length() != 5)

   402         {

   403         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);

   404         return;

   405         }

   406     

   407     CEngineVideoRecording::TZoomMode zoomMode = (CEngineVideoRecording::TZoomMode)aData[0];

   408     HTI_LOG_FORMAT("Set zoom mode: %d", zoomMode);

   409     TRAPD(err, iVideoRecordingEngine->SetZoomModeL(zoomMode));

   410     if(err != KErrNone)

   411         {

   412         SendErrorMessageL(err, KErrorSetZoomModeFailed);

   413         }

   414     else

   415         {

   416         TInt value = aData[1] + ( aData[2] << 8 )

   417                 + ( aData[3] << 16 )

   418                 + ( aData[4] << 24 );

   419         HTI_LOG_FORMAT("Set zoom value: %d", value);

   420         TRAPD(err, iVideoRecordingEngine->SetZoomValueL(value));

   421         if(err != KErrNone)

   422             {

   423             SendErrorMessageL(err, KErrorSetZoomValueFailed);

   424             }

   425         else

   426             {

   427             SendOkMsgL(KNullDesC8);

   428             }

   429         }

   430     

   431     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleSetZoomCmdL" );

   432     }

   433 

   434 

   435 // -----------------------------------------------------------------------------

   436 // CHtiCameraServicePlugin::IsBusy

   437 // -----------------------------------------------------------------------------

   438 //

   439 TBool CHtiCameraServicePlugin::IsBusy()

   440     {

   441     return iIsBusy;

   442     }

   443 

   444 

   445 // ----------------------------------------------------------------------------

   446 void CHtiCameraServicePlugin::SendOkMsgL( const TDesC8& aData )

   447     {

   448     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::SendOkMsgL: Starting" );

   449 

   450     User::LeaveIfNull( iDispatcher );

   451 

   452     HBufC8* temp = HBufC8::NewL( aData.Length() + 1 );

   453     TPtr8 response = temp->Des();

   454     response.Append( ( TChar ) EResultOk );

   455     response.Append( aData );

   456     User::LeaveIfError( iDispatcher->DispatchOutgoingMessage(

   457         temp, KCameraServiceUid ) );

   458     iIsBusy = EFalse;

   459     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::SendOkMsgL: Done" );

   460     }

   461 

   462 // ----------------------------------------------------------------------------

   463 void CHtiCameraServicePlugin::SendErrorMessageL( TInt aError, const TDesC8& aDescription )

   464     {

   465     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::SendErrorMessageL: Starting" );

   466     User::LeaveIfNull( iDispatcher );

   467     User::LeaveIfError( iDispatcher->DispatchOutgoingErrorMessage(

   468         aError, aDescription, KCameraServiceUid ) );

   469     iIsBusy = EFalse;

   470     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::SendErrorMessageL: Done" );

   471     }

   472 

   473 TInt CHtiCameraServicePlugin::ParseString( const TDesC8& aRequest,

   474                                           TInt aOffset,

   475                                           TDes& aResult )

   476     {

   477     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::ParseString" );

   478 

   479     // If offset outside the string return empty string

   480     if ( aOffset >= aRequest.Size() )

   481         {

   482         return aOffset;

   483         }

   484 

   485     TInt length = aRequest[aOffset];

   486     HTI_LOG_FORMAT( "String length = %d", length );

   487 

   488     // If length is zero return empty string

   489     if ( length < 1 )

   490         {

   491         return aOffset + 1;

   492         }

   493 

   494     if ( length > aResult.MaxLength() )

   495         {

   496         return KErrBadDescriptor;

   497         }

   498 

   499     TInt nextOffset = length + aOffset + 1;

   500     HTI_LOG_FORMAT( "Next offset = %d", nextOffset );

   501     HTI_LOG_FORMAT( "Request size = %d", aRequest.Size() );

   502 

   503     if ( nextOffset > aRequest.Size() )

   504         {

   505         return KErrArgument;

   506         }

   507 

   508     aResult.Copy( aRequest.Mid( aOffset + 1, length ) );

   509 

   510     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::ParseString" );

   511     return nextOffset;

   512     }

   513 

   514 void CHtiCameraServicePlugin::MevroInitComplete( TInt aError )

   515     {

   516     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroInitComplete" );

   517     HTI_LOG_FORMAT("aError = %d", aError);

   518     iWaiter->AsyncStop();

   519     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroInitComplete" );

   520     }

   521 

   522 void CHtiCameraServicePlugin::MevroVideoPrepareComplete(TInt aError)

   523     {

   524     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroVideoPrepareComplete" );

   525     HTI_LOG_FORMAT("aError = %d", aError);

   526     iWaiter->AsyncStop();

   527     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroVideoPrepareComplete" );

   528     }

   529 

   530 void CHtiCameraServicePlugin::MevroVideoRecordingOn(TInt aError)

   531     {

   532     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroVideoRecordingOn" );

   533     HTI_LOG_FORMAT("aError = %d", aError);

   534     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroVideoRecordingOn" );

   535     }

   536 

   537 void CHtiCameraServicePlugin::MevroVideoRecordingPaused(TInt aError)

   538     {

   539     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroVideoRecordingPaused" );

   540     HTI_LOG_FORMAT("aError = %d", aError);

   541     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroVideoRecordingPaused" );

   542     }

   543 

   544 void CHtiCameraServicePlugin::MevroVideoRecordingComplete(TInt aError)

   545     {

   546     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroVideoRecordingComplete" );

   547     HTI_LOG_FORMAT("aError = %d", aError);

   548     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroVideoRecordingComplete" );

   549     }

   550 //  End of File