TB10.1 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         
-