htiui/HtiServicePlugins/HtiCameraServicePlugin/src/HtiCameraServicePlugin.cpp
branchRCL_3
changeset 42 d40e813b23c0
parent 33 65b472535a0d
equal deleted inserted replaced
33:65b472535a0d 42:d40e813b23c0
    42 // in HtiDispatcherInterface.h (currently 118).
    42 // in HtiDispatcherInterface.h (currently 118).
    43 
    43 
    44 _LIT8( KErrorNoCommand, "ERROR: No command given" );
    44 _LIT8( KErrorNoCommand, "ERROR: No command given" );
    45 _LIT8( KErrorUnknownCmd, "ERROR: Unknown Camera Service command" );
    45 _LIT8( KErrorUnknownCmd, "ERROR: Unknown Camera Service command" );
    46 _LIT8( KErrorInitFailed, "ERROR: Failed to init");
    46 _LIT8( KErrorInitFailed, "ERROR: Failed to init");
       
    47 _LIT8( KErrorUninitialized, "ERROR: Uninitialized");
    47 _LIT8( KErrInvalidateParameters, "ERROR: Invalidate parameters");
    48 _LIT8( KErrInvalidateParameters, "ERROR: Invalidate parameters");
    48 _LIT8( KErrQualityLevel, "ERROR: Invalidate quality level");
    49 _LIT8( KErrQualityLevel, "ERROR: Invalidate quality level");
    49 _LIT8( KErrorPrepareVideoRecordingFailed, "ERROR: Prepare video recording failed");
    50 _LIT8( KErrorPrepareVideoRecordingFailed, "ERROR: Prepare video recording failed");
    50 _LIT8( KErrorStartVideoRecordingFailed, "ERROR: Start video recording failed");
    51 _LIT8( KErrorStartVideoRecordingFailed, "ERROR: Start video recording failed");
    51 _LIT8( KErrorPausingVideoRecordingFailed, "ERROR: Pausing video recording failed");
    52 _LIT8( KErrorPausingVideoRecordingFailed, "ERROR: Pausing video recording failed");
    81 // -----------------------------------------------------------------------------
    82 // -----------------------------------------------------------------------------
    82 //
    83 //
    83 void CHtiCameraServicePlugin::ConstructL()
    84 void CHtiCameraServicePlugin::ConstructL()
    84     {
    85     {
    85     HTI_LOG_TEXT( "CHtiCameraServicePlugin::ConstructL" );
    86     HTI_LOG_TEXT( "CHtiCameraServicePlugin::ConstructL" );
    86     iVideoRecordingEngine = CEngineVideoRecording::NewL(*this, 0);
       
    87     iWaiter = new ( ELeave ) CActiveSchedulerWait;
    87     iWaiter = new ( ELeave ) CActiveSchedulerWait;
    88     }
    88     }
    89 
    89 
    90 
    90 
    91 // -----------------------------------------------------------------------------
    91 // -----------------------------------------------------------------------------
   104 
   104 
   105 
   105 
   106 // Destructor
   106 // Destructor
   107 CHtiCameraServicePlugin::~CHtiCameraServicePlugin()
   107 CHtiCameraServicePlugin::~CHtiCameraServicePlugin()
   108     {
   108     {
   109     delete iVideoRecordingEngine;
   109     if(iVideoRecordingEngine)
   110     iVideoRecordingEngine = NULL;
   110         {
       
   111         delete iVideoRecordingEngine;
       
   112         iVideoRecordingEngine = NULL;
       
   113         }
   111     
   114     
   112     delete iWaiter;
   115     delete iWaiter;
   113     iWaiter = NULL;
   116     iWaiter = NULL;
   114     }
   117     }
   115 
   118 
   144     TUint8 command = aMessage.Ptr()[0];
   147     TUint8 command = aMessage.Ptr()[0];
   145     TInt err = KErrNone;
   148     TInt err = KErrNone;
   146 
   149 
   147     switch (command)
   150     switch (command)
   148         {
   151         {
   149         case ECmdInit:
   152         case ECmdInitialize:
   150             TRAP(err, HandleInitCmdL(aMessage.Right( aMessage.Length() - 1 )));
   153             TRAP(err, HandleInitializeCmdL(aMessage.Right( aMessage.Length() - 1 )));
       
   154             break;
       
   155         case ECmdUninitialize:
       
   156             TRAP(err, HandleUninitializeCmdL(aMessage.Right( aMessage.Length() - 1 )));
   151             break;
   157             break;
   152         case ECmdPrepareVideoRecording:
   158         case ECmdPrepareVideoRecording:
   153             TRAP(err, HandlePrepareVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));
   159             TRAP(err, HandlePrepareVideoRecordingCmdL(aMessage.Right( aMessage.Length() - 1 )));
   154             break;
   160             break;
   155         case ECmdStartVideoRecording:
   161         case ECmdStartVideoRecording:
   185         }
   191         }
   186 
   192 
   187     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::ProcessMessageL" );
   193     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::ProcessMessageL" );
   188     }
   194     }
   189 
   195 
   190 void CHtiCameraServicePlugin::HandleInitCmdL( const TDesC8& aData )
   196 void CHtiCameraServicePlugin::HandleInitializeCmdL( const TDesC8& aData )
   191     {
   197     {
   192     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleInitCmdL" );
   198     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleInitializeCmdL" );
   193     if(aData.Length() != 0)
   199     if(aData.Length() != 0)
   194         {
   200         {
   195         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   201         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   196         return;
   202         return;
   197         }
   203         }
   198     
   204     
   199     HTI_LOG_TEXT("Initializes Camera Application Engine");
   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);
   200     iVideoRecordingEngine->InitL();
   213     iVideoRecordingEngine->InitL();
   201     iWaiter->Start();
   214     iWaiter->Start();
   202     if(iError != KErrNone)
   215     if(iError != KErrNone)
   203         {
   216         {
   204         SendErrorMessageL(iError, KErrorInitFailed);
   217         SendErrorMessageL(iError, KErrorInitFailed);
   209         iVideoRecordingEngine->InitVideoRecorderL();
   222         iVideoRecordingEngine->InitVideoRecorderL();
   210         
   223         
   211         SendOkMsgL(KNullDesC8);
   224         SendOkMsgL(KNullDesC8);
   212         }
   225         }
   213 
   226 
   214     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleInitCmdL" );
   227     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::HandleInitializeCmdL" );
   215     }
   228     }
   216 
   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     }
   217 
   251 
   218 void CHtiCameraServicePlugin::HandlePrepareVideoRecordingCmdL( const TDesC8& aData )
   252 void CHtiCameraServicePlugin::HandlePrepareVideoRecordingCmdL( const TDesC8& aData )
   219     {
   253     {
   220     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandlePrepareVideoRecordingCmdL" );
   254     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandlePrepareVideoRecordingCmdL" );
   221     if(aData.Length() < 2 || aData[1] != aData.Length() -2)
   255     if(aData.Length() < 2 || aData[1] != aData.Length() -2)
   222         {
   256         {
   223         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   257         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   258         return;
       
   259         }
       
   260     
       
   261     if(iVideoRecordingEngine == NULL)
       
   262         {
       
   263         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
   224         return;
   264         return;
   225         }
   265         }
   226     
   266     
   227     TInt qualityLevelIndex = aData[0];
   267     TInt qualityLevelIndex = aData[0];
   228     if(qualityLevelIndex < 0 || qualityLevelIndex > iVideoRecordingEngine->VideoQualityCount() -1)
   268     if(qualityLevelIndex < 0 || qualityLevelIndex > iVideoRecordingEngine->VideoQualityCount() -1)
   265         {
   305         {
   266         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   306         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   267         return;
   307         return;
   268         }
   308         }
   269     
   309     
       
   310     if(iVideoRecordingEngine == NULL)
       
   311         {
       
   312         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
       
   313         return;
       
   314         }
       
   315     
   270     HTI_LOG_TEXT("Start video recording...");
   316     HTI_LOG_TEXT("Start video recording...");
   271     iVideoRecordingEngine->StartVideoRecording();
   317     iVideoRecordingEngine->StartVideoRecording();
   272     
   318     
   273     if(iError != KErrNone)
   319     if(iError != KErrNone)
   274         {
   320         {
   286     {
   332     {
   287     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandlePausingVideoRecordingCmdL" );
   333     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandlePausingVideoRecordingCmdL" );
   288     if(aData.Length() != 0)
   334     if(aData.Length() != 0)
   289         {
   335         {
   290         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   336         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   337         return;
       
   338         }
       
   339     
       
   340     if(iVideoRecordingEngine == NULL)
       
   341         {
       
   342         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
   291         return;
   343         return;
   292         }
   344         }
   293     
   345     
   294     HTI_LOG_TEXT("Pausing video recording");
   346     HTI_LOG_TEXT("Pausing video recording");
   295     iVideoRecordingEngine->PauseVideoRecording();
   347     iVideoRecordingEngine->PauseVideoRecording();
   311         {
   363         {
   312         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   364         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   313         return;
   365         return;
   314         }
   366         }
   315     
   367     
       
   368     if(iVideoRecordingEngine == NULL)
       
   369         {
       
   370         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
       
   371         return;
       
   372         }
       
   373     
   316     HTI_LOG_TEXT("Resume video recording...");
   374     HTI_LOG_TEXT("Resume video recording...");
   317     iVideoRecordingEngine->ResumeVideoRecording();
   375     iVideoRecordingEngine->ResumeVideoRecording();
   318     
   376     
   319     if(iError != KErrNone)
   377     if(iError != KErrNone)
   320         {
   378         {
   331     {
   389     {
   332     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleStopVideoRecordingCmdL" );
   390     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleStopVideoRecordingCmdL" );
   333     if(aData.Length() != 0)
   391     if(aData.Length() != 0)
   334         {
   392         {
   335         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   393         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   394         return;
       
   395         }
       
   396     
       
   397     if(iVideoRecordingEngine == NULL)
       
   398         {
       
   399         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
   336         return;
   400         return;
   337         }
   401         }
   338     
   402     
   339     HTI_LOG_TEXT("Stop video recording");
   403     HTI_LOG_TEXT("Stop video recording");
   340     iVideoRecordingEngine->StopVideoRecording();
   404     iVideoRecordingEngine->StopVideoRecording();
   353     {
   417     {
   354     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleCloseVideoRecordingCmdL" );
   418     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleCloseVideoRecordingCmdL" );
   355     if(aData.Length() != 0)
   419     if(aData.Length() != 0)
   356         {
   420         {
   357         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   421         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   422         return;
       
   423         }
       
   424     
       
   425     if(iVideoRecordingEngine == NULL)
       
   426         {
       
   427         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
   358         return;
   428         return;
   359         }
   429         }
   360     
   430     
   361     HTI_LOG_TEXT("Close video recording");
   431     HTI_LOG_TEXT("Close video recording");
   362     iVideoRecordingEngine->CloseVideoRecording();
   432     iVideoRecordingEngine->CloseVideoRecording();
   368     {
   438     {
   369     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleGetZoomCmdL" );
   439     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleGetZoomCmdL" );
   370     if(aData.Length() != 0)
   440     if(aData.Length() != 0)
   371         {
   441         {
   372         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   442         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   443         return;
       
   444         }
       
   445     
       
   446     if(iVideoRecordingEngine == NULL)
       
   447         {
       
   448         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
   373         return;
   449         return;
   374         }
   450         }
   375     
   451     
   376     TUint8 zoomMode = (TUint8)iVideoRecordingEngine->ZoomMode();
   452     TUint8 zoomMode = (TUint8)iVideoRecordingEngine->ZoomMode();
   377     HTI_LOG_FORMAT("Current zoom mode: %d", zoomMode);
   453     HTI_LOG_FORMAT("Current zoom mode: %d", zoomMode);
   399     {
   475     {
   400     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleSetZoomCmdL" );
   476     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::HandleSetZoomCmdL" );
   401     if(aData.Length() != 5)
   477     if(aData.Length() != 5)
   402         {
   478         {
   403         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
   479         SendErrorMessageL(KErrArgument, KErrInvalidateParameters);
       
   480         return;
       
   481         }
       
   482     
       
   483     if(iVideoRecordingEngine == NULL)
       
   484         {
       
   485         SendErrorMessageL(KErrNotReady, KErrorUninitialized);
   404         return;
   486         return;
   405         }
   487         }
   406     
   488     
   407     CEngineVideoRecording::TZoomMode zoomMode = (CEngineVideoRecording::TZoomMode)aData[0];
   489     CEngineVideoRecording::TZoomMode zoomMode = (CEngineVideoRecording::TZoomMode)aData[0];
   408     HTI_LOG_FORMAT("Set zoom mode: %d", zoomMode);
   490     HTI_LOG_FORMAT("Set zoom mode: %d", zoomMode);
   513 
   595 
   514 void CHtiCameraServicePlugin::MevroInitComplete( TInt aError )
   596 void CHtiCameraServicePlugin::MevroInitComplete( TInt aError )
   515     {
   597     {
   516     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroInitComplete" );
   598     HTI_LOG_FUNC_IN( "CHtiCameraServicePlugin::MevroInitComplete" );
   517     HTI_LOG_FORMAT("aError = %d", aError);
   599     HTI_LOG_FORMAT("aError = %d", aError);
   518     iError = aError;
   600     iError = aError; 
   519     iWaiter->AsyncStop();
   601     iWaiter->AsyncStop();
   520     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroInitComplete" );
   602     HTI_LOG_FUNC_OUT( "CHtiCameraServicePlugin::MevroInitComplete" );
   521     }
   603     }
   522 
   604 
   523 void CHtiCameraServicePlugin::MevroVideoPrepareComplete(TInt aError)
   605 void CHtiCameraServicePlugin::MevroVideoPrepareComplete(TInt aError)