TB9.2 Example Applications: examples/Multimedia/MmfRec/src/mmfrec.cpp Source File

00001 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+00002 // All rights reserved.
+00003 // This component and the accompanying materials are made available
+00004 // under the terms of "Eclipse Public License v1.0"
+00005 // which accompanies this distribution, and is available
+00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
+00007 //
+00008 // Initial Contributors:
+00009 // Nokia Corporation - initial contribution.
+00010 //
+00011 // Contributors:
+00012 //
+00013 // Description:
+00014 //
+00015 
+00016 #include <e32base.h>
+00017 #include <e32cons.h>
+00018 #include <mdaaudiosampleeditor.h>
+00019 #include <bautils.h>
+00020 #include <ecom/ecom.h>
+00021 #include "mmfrec.h"
+00022 
+00023 _LIT(KFileNameFormat, "c:\\record%03d%S");
+00024 
+00025 const TInt KRecordTimeMicros = 2000000; //2s
+00026 
+00027 TInt E32Main()
+00028         {
+00029         __UHEAP_MARK;
+00030 
+00031         CTrapCleanup* cleanup=CTrapCleanup::New();
+00032         TInt r=KErrNoMemory;
+00033         if (cleanup)
+00034                 {
+00035                 TRAP(r,MainL());
+00036                 delete cleanup;
+00037                 }
+00038         REComSession::FinalClose();
+00039         __UHEAP_MARKEND;
+00040 
+00041         return r;
+00042         }
+00043         
+00044 void MainL()
+00045         {
+00046         // The recorder utility requires an active scheduler to be running in the thread before
+00047         // it can be used. This would normally be done by the application framework
+00048         CActiveScheduler* s=new(ELeave) CActiveScheduler;
+00049         CleanupStack::PushL(s);
+00050         CActiveScheduler::Install(s);
+00051         
+00052         CMMFRecordTest* test = CMMFRecordTest::NewLC();
+00053         
+00054         test->Go();
+00055 
+00056         CActiveScheduler::Start();
+00057         CleanupStack::PopAndDestroy(2);
+00058         }
+00059         
+00060 
+00061 //______________________________________________________________________________
+00062 //                                              CMMFRecordTest
+00063 CMMFRecordTest* CMMFRecordTest::NewLC()
+00064         {
+00065         CMMFRecordTest* self = new(ELeave)CMMFRecordTest();
+00066         CleanupStack::PushL(self);
+00067         self->ConstructL();
+00068         return self;
+00069         }
+00070 
+00071 CMMFRecordTest::~CMMFRecordTest()
+00072         {
+00073         delete iRecorder;
+00074         delete iConsole;
+00075         delete iCallBack;
+00076         delete iTimer;
+00077         iFs.Close();
+00078         for (TInt i=0; i<iControllers.Count(); ++i)
+00079                 {
+00080                 delete iControllers[i];
+00081                 }
+00082         iControllers.Close();
+00083         }
+00084         
+00085 void CMMFRecordTest::NextState(TState aState)
+00086         {
+00087         iState = aState;
+00088         iCallBack->Set(iCbFn);
+00089         iCallBack->CallBack();
+00090         }
+00091 
+00092 void CMMFRecordTest::Go()
+00093         {
+00094         NextState(ENone);
+00095         }
+00096 
+00102 void CMMFRecordTest::MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)
+00103         {
+00104         
+00105         __ASSERT_ALWAYS(aObject == iRecorder, User::Panic(_L("Objects NotEqual"),KErrNotFound));
+00106         
+00107         switch (iState)
+00108                 {
+00109         case EInitFile:
+00110                 Printf(_L("Initialising file:"));
+00111                 break;
+00112         case EInitDesc:
+00113                 Printf(_L("Initialising des:"));
+00114                 break;
+00115         case ENone:
+00116         case EDoOpenFile:
+00117         case ERecordFile:
+00118         case EDoOpenDesc:
+00119         case ERecordDesc:
+00120         case ENext:
+00121         case EDone:
+00122         default:
+00123                         break;
+00124                 }
+00125 
+00126         Printf(_L("MoscoStateChangeEvent(%d, %d, %d)"), aPreviousState, aCurrentState, aErrorCode);     
+00127 
+00128         TTimeIntervalMicroSeconds32 delay(KRecordTimeMicros);
+00129 
+00130         switch (iState)
+00131                 {
+00132         case EInitFile:
+00133                 if (aErrorCode == KErrNone)
+00134                         { // file was opened successfully
+00135                         Printf(_L("call: RecordL() (to file)"));
+00136                         iState = ERecordFile;
+00137                         TRAPD(err,iRecorder->RecordL());
+00138                         if(err)
+00139                                 {
+00140                                 return;
+00141                                 }
+00142                         iTimer->Start(delay, delay, iCbFn);
+00143                         }
+00144                 else
+00145                         {
+00146                         Printf(_L("OpenFile failed with error %d"), aErrorCode);
+00147                         // move onto next stage: record to descriptor
+00148                         NextState(EDoOpenDesc);
+00149                         }
+00150                 break;
+00151         case EInitDesc:
+00152                 if (aErrorCode == KErrNone)
+00153                         {
+00154                         Printf(_L("call: RecordL() (to des)"));
+00155                         iState = ERecordDesc;
+00156                         TRAPD(err,iRecorder->RecordL());
+00157                         if(err)
+00158                                 {
+00159                                 return;
+00160                                 }
+00161                         iTimer->Start(delay, delay, iCbFn);
+00162                         }
+00163                 else
+00164                         {
+00165                         Printf(_L("OpenDesc failed with error %d"), aErrorCode);
+00166                         // move onto next stage: try next format
+00167                         NextState(ENext);
+00168                         }                       
+00169                 break;
+00170         case ERecordFile:
+00171                 // an error has occurred during recording. Stop the recording and move onto the next test.
+00172                 if (aCurrentState!=CMdaAudioClipUtility::ERecording)
+00173                         {
+00174                         iTimer->Cancel();
+00175                         Printf(_L("call: Stop()"));
+00176                         iRecorder->Stop();
+00177                         NextState(EDoOpenDesc);
+00178                         }
+00179                 break;
+00180         case ERecordDesc:
+00181                 // an error has occurred during recording. Stop the recording and move onto the next test.
+00182                 if (aCurrentState!=CMdaAudioClipUtility::ERecording)
+00183                         {
+00184                         iTimer->Cancel();
+00185                         Printf(_L("call: Stop()"));
+00186                         iRecorder->Stop();
+00187                         NextState(ENext);
+00188                         }
+00189                 break;
+00190         case ENone:
+00191         case EDoOpenFile:
+00192         case EDoOpenDesc:
+00193         case ENext:
+00194         case EDone:
+00195         default:
+00196                         break;
+00197         
+00198                 }
+00199         }
+00200         
+00201 CMMFRecordTest::CMMFRecordTest()
+00202         {
+00203         }
+00204 
+00205 void CMMFRecordTest::ConstructL()
+00206         {
+00207         iCallBack = new(ELeave)CAsyncCallBack(CActive::EPriorityStandard);
+00208         iTimer = CPeriodic::NewL(CActive::EPriorityStandard);
+00209         iConsole = Console::NewL(_L(" RecTest "), TSize(KConsFullScreen, KConsFullScreen));
+00210         User::LeaveIfNull(iConsole);
+00211         iRecorder = CMdaAudioRecorderUtility::NewL(*this);
+00212         User::LeaveIfError(iFs.Connect());
+00213         
+00214         iCbFn = TCallBack(Callback, this);
+00215         }
+00216 
+00221 void CMMFRecordTest::GetPluginInformationL()
+00222         {
+00223         CMMFControllerPluginSelectionParameters* controllerSelection = NULL;
+00224         CMMFFormatSelectionParameters* formatSelect = NULL;
+00225 
+00226         iControllers.ResetAndDestroy();
+00227         iControllers.Close();
+00228 
+00229         controllerSelection = CMMFControllerPluginSelectionParameters::NewLC();
+00230 
+00231         RArray<TUid> mediaIds; //Array to hold media types we wish to support
+00232         CleanupClosePushL(mediaIds);
+00233         
+00234         // specify that we're interested in audio
+00235         mediaIds.AppendL(KUidMediaTypeAudio);
+00236         controllerSelection->SetMediaIdsL(
+00237                 mediaIds, CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds);
+00238 
+00239         formatSelect = CMMFFormatSelectionParameters::NewLC();
+00240         /*
+00241         specify that were only interested in formats for recording.
+00242         If you were intersted in recording to a specific format rather than just excercising
+00243         every record format supported by the system, you could (for example) specify which 
+00244         format by calling formatSelect->SetMatchToMimeTypeL().  
+00245         */
+00246         controllerSelection->SetRequiredRecordFormatSupportL(*formatSelect);
+00247         
+00248         // get the list of controller plugins that support audio recording in one or 
+00249         // more formats.
+00250         controllerSelection->ListImplementationsL(iControllers);
+00251         
+00252         // iControllers now contains details of all audio controller plugins that support
+00253         // audio recording. Each of the controller in the array will support one or more
+00254         // recording formats.
+00255         Printf(_L("GetPluginInformationL() - iControllers.Count() : %d"), iControllers.Count());
+00256 
+00257         CleanupStack::PopAndDestroy(3, controllerSelection);
+00258         }
+00259 
+00260 void CMMFRecordTest::Printf(TRefByValue<const TDesC16> aFmt, ...)
+00261         {
+00262         VA_LIST list;
+00263         VA_START(list, aFmt);
+00264 
+00265         TTruncateOverflow overflow;
+00266         iFormattingBuf.Zero();
+00267         iFormattingBuf.AppendFormatList(aFmt, list, &overflow);
+00268         
+00269         // output the message to the console on the screen, and also to debug output
+00270         iConsole->Printf(iFormattingBuf);
+00271         iConsole->Printf(_L("\n"));
+00272         RDebug::RawPrint(iFormattingBuf);
+00273         }
+00274         
+00275 TInt CMMFRecordTest::Callback(TAny* self)
+00276         {
+00277         TState state = ((CMMFRecordTest*)self)->iState;
+00278         TRAPD(err, ((CMMFRecordTest*)self)->DoCallbackL());
+00279         if (err!=KErrNone)
+00280                 {
+00281                 ((CMMFRecordTest*)self)->Printf(_L("Left with %d in state %d"), err, state);
+00282                 }
+00283         return err;             
+00284         }
+00285         
+00286 void CMMFRecordTest::DoCallbackL()
+00287         {
+00288         iTimer->Cancel();
+00289         switch (iState)
+00290                 {
+00291         case ENone:
+00292                 // start by getting details of all the 
+00293                 GetPluginInformationL();
+00294                 iControllerIndex = 0;
+00295                 iFormatIndex = 0;
+00296                 // get the detail of the first format UID
+00297                 if (GetNextFormatUid())
+00298                         {
+00299                         // and begin initialization
+00300                         NextState(EDoOpenFile);
+00301                         }
+00302                 else
+00303                         {
+00304                         // if this fails for some reason, move onto the next controller
+00305                         Next();
+00306                         }
+00307                 break;
+00308                 
+00309         case EDoOpenFile:
+00310                 InitializeFileL();
+00311                 break;
+00312                 
+00313         case EDoOpenDesc:
+00314                 InitializeDesL();
+00315                 break;
+00316                 
+00317         case ERecordFile:
+00318                 // stop recording to a file after the timer expires
+00319                 Printf(_L("call: Stop()"));
+00320                 iRecorder->Stop();
+00321                 NextState(EDoOpenDesc);
+00322                 break;
+00323 
+00324         case ERecordDesc:
+00325                 // stop recording to a descriptor after the timer expires
+00326                 Printf(_L("call: Stop()"));
+00327                 iRecorder->Stop();
+00328                 NextState(ENext);
+00329                 break;
+00330 
+00331         case ENext:
+00332                 Next();
+00333                 break;
+00334                 
+00335         case EDone:
+00336                 CActiveScheduler::Stop();
+00337                 break;
+00338         case EInitFile:
+00339         case EInitDesc:
+00340         default:
+00341                         break;
+00342 
+00343                 }
+00344         
+00345         
+00346         }
+00347         
+00351 void CMMFRecordTest::Next()
+00352         {
+00353         if (iControllerIndex >= iControllers.Count())
+00354                 {
+00355                 NextState(EDone);
+00356                 return;
+00357                 }
+00358                 
+00359         CMMFControllerImplementationInformation* info = iControllers[iControllerIndex];
+00360         
+00361         ++iFormatIndex;
+00362         
+00363         if (iFormatIndex >= info->RecordFormats().Count())
+00364                 {
+00365                 iFormatIndex = -1;
+00366                 ++iControllerIndex;
+00367                 NextState(ENext);
+00368                 return;
+00369                 }       
+00370                 
+00371         NextState(GetNextFormatUid() ? EDoOpenFile : EDone);    
+00372         }
+00373         
+00377 TBool CMMFRecordTest::GetNextFormatUid()
+00378         {
+00379         // if we have already excercised all of the controllers, then finish:
+00380         if (iControllerIndex >= iControllers.Count())
+00381                 {
+00382                 return EFalse;
+00383                 }
+00384                 
+00385         CMMFControllerImplementationInformation* info = iControllers[iControllerIndex];
+00386         
+00387         // if we have already tried all record formats supported by the current
+00388         // controller, then move onto the next:
+00389         if (iFormatIndex >= info->RecordFormats().Count())
+00390                 {
+00391                 return EFalse;
+00392                 }
+00393                 
+00394         // get the unique IDs of the controller and the record format we're using
+00395         iControllerUid = info->Uid();
+00396         iDestinationFormatUid = info->RecordFormats()[iFormatIndex]->Uid();
+00397         
+00398         // find the recommended extension for a file of this format
+00399         iExtension.Zero();
+00400         const CDesC8Array& extns = info->RecordFormats()[iFormatIndex]->SupportedFileExtensions();
+00401         if (extns.Count()>0)
+00402                 {
+00403                 iExtension.Copy(extns[0]);
+00404                 }
+00405         
+00406         // finally display some information about the format we're using
+00407         Printf(_L("Using controller '%S', record format '%S'"), &info->DisplayName(), &info->RecordFormats()[iFormatIndex]->DisplayName());
+00408                 
+00409                 
+00410         return ETrue;
+00411         }
+00412 
+00413 void CMMFRecordTest::DeleteFileL(const TDesC& aFileName)
+00414         {
+00415         TInt result = BaflUtils::DeleteFile(iFs, aFileName);
+00416 
+00417         if ((result != KErrNotFound)&&(result!=KErrPathNotFound))
+00418                 {
+00419                 User::LeaveIfError(result);
+00420                 }
+00421         }
+00422 
+00427 void CMMFRecordTest::InitializeFileL()
+00428         {
+00429         iFileName.Zero();
+00430         iFileName.Format(KFileNameFormat, iFileNum, &iExtension);
+00431         
+00432         // delte the file if it already exists
+00433         DeleteFileL(iFileName);
+00434         
+00435         Printf(_L("call: OpenFileL(%S, %x, %x, %x)"), &iFileName, iControllerUid, KNullUid, iDestinationFormatUid);
+00436         iState = EInitFile;
+00437         iRecorder->OpenFileL(iFileName, iControllerUid, KNullUid, iDestinationFormatUid);
+00438         
+00439         ++iFileNum;
+00440         }
+00441         
+00446 void CMMFRecordTest::InitializeDesL()
+00447         {
+00448         Printf(_L("call: OpenDesL(buf, %x, %x, %x)"), iControllerUid, KNullUid, iDestinationFormatUid);
+00449         iState = EInitDesc;
+00450         iRecorder->OpenDesL(iRecBuf, iControllerUid, KNullUid, iDestinationFormatUid);
+00451         }
+00452 
+00453 
+00454 
+00455         
+