examples/Multimedia/AudioClientEx/CMediaClientEngine.cpp

00001 // Copyright (c) 2001-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 "CMediaClientEngine.h"
00017 
00018 // Global helper function to change extension on a file
00019 void ChangeExtension(const TFileName& aFile, const TDesC& aTargetType,
00020         TFileName& aTargetFile);
00021 //
00022 /************** CONSTRUCTION AND DESTRUCTION ******************/
00023 //
00024 
00025 CMediaClientEngine::CMediaClientEngine(RFs& aFs)
00026         : iFs(aFs),
00027         iState(CMediaClientEngine::EIdle),
00028         iVolume(CMediaClientEngine::EMedium)
00029         {
00030         }
00031 
00032 CMediaClientEngine::~CMediaClientEngine()
00033         {
00034         iEngineObserver = 0;
00035         Stop();
00036         }
00037 
00038 //
00039 /************** GENERAL FUNCTIONS ******************/
00040 //
00041 
00042 void CMediaClientEngine::SetObserver(MExEngineObserver& aObserver)
00043         {
00044         iEngineObserver = &aObserver;
00045         }
00046 
00047 
00048 // Terminate current operation
00049 void CMediaClientEngine::Stop()
00050         {
00051         // Take appropriate action depending on what the state is
00052         switch (iState)
00053                 {
00054                 case ETonePrepare:
00055                         iAudioToneUtility->CancelPrepare();
00056                         ToneCleanup();
00057                         break;
00058                 case ETonePlaying:
00059                 iAudioToneUtility->CancelPlay();
00060                         ToneCleanup();
00061                         break;
00062                 case EPlayFilePrepare:
00063                         PlayCleanup();
00064                         break;
00065                 case EPlayFilePlaying:
00066                         iAudioPlayUtility->Stop();
00067                         PlayCleanup();
00068                         break;
00069                 case ERecordPrepare:
00070                         RecordCleanup();
00071                         break;
00072                 case ERecording:
00073                         iAudioRecorderUtility -> Stop();
00074                         RecordCleanup();
00075                         break;
00076                 case EConvert:
00077                         ConvertCleanup();
00078                         break;
00079                 case EStreamPrepare:
00080                         StreamCleanup();
00081                         break;
00082                 case EStreamStarted:
00083                 case ENextStreamBuf:
00084                         iAudioStreamPlayer -> Stop(); // Calls MaoscBufferCopied() with KErrAbort
00085                         iState = EStreamStopping;
00086                         break;
00087                 default:
00088                         break;
00089                 };
00090         // And tell the UI about the state change
00091         if (iEngineObserver)
00092                 iEngineObserver -> HandleEngineState(iState,KErrNone);
00093         }
00094 
00095 // Get volume
00096 CMediaClientEngine::TExVolume CMediaClientEngine::Volume() const
00097         {
00098         return iVolume;
00099         }
00100 
00101 // Set volume
00102 void CMediaClientEngine::SetVolume(CMediaClientEngine::TExVolume aVolume)
00103         {
00104         iVolume = aVolume;
00105         if (iAudioStreamPlayer) // Streaming is in progress
00106                 {
00107                 iAudioStreamPlayer -> SetVolume(iAudioStreamPlayer -> MaxVolume()/iVolume);
00108                 }       
00109         }
00110 
00111 // Get state
00112 CMediaClientEngine::TState CMediaClientEngine::Status() const
00113         {
00114         return iState;
00115         }
00116 
00117 // Panic
00118 void CMediaClientEngine::Panic(CMediaClientEngine::TPanics aPanic)
00119         {
00120         _LIT(KPanic,"MEDIA_AUDIO_EX");
00121         User::Panic(KPanic,aPanic);
00122         }
00123 
00124 
00125 //
00126 /************** TONE PLAYING ******************/
00127 //
00128 
00129 // Play a tone of specified frequency and duration
00130 void CMediaClientEngine::PlayL(TInt aFrequency, 
00131                                                            const TTimeIntervalMicroSeconds& aDuration)
00132         {
00133         __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00134         
00135         iAudioToneUtility = CMdaAudioToneUtility::NewL(*this);
00136         iState = ETonePrepare;
00137         iAudioToneUtility -> PrepareToPlayTone(aFrequency, aDuration);
00138         // This will call back MatoPrepareComplete() when preparation is complete
00139         }
00140 
00141 // Audio is now prepared to play a tone
00142 // from MMdaAudioToneObserver
00143 void CMediaClientEngine::MatoPrepareComplete(TInt aError)
00144         {
00145         __ASSERT_DEBUG(iEngineObserver, Panic(CMediaClientEngine::ENullObserver));
00146         __ASSERT_DEBUG(iAudioToneUtility, Panic(CMediaClientEngine::ENullTonePlayer));
00147         __ASSERT_DEBUG(iState == ETonePrepare, Panic(CMediaClientEngine::EWrongState));
00148         
00149         // If preparation was sucessful, play the tone
00150         if (aError)
00151                 ToneCleanup();
00152         else
00153                 {
00154                 iState = ETonePlaying;
00155                 iAudioToneUtility -> SetVolume(iAudioToneUtility -> MaxVolume()/iVolume);
00156                 iAudioToneUtility -> Play();
00157                 }
00158         iEngineObserver -> HandleEngineState(iState,aError);
00159         }
00160 
00161 // Audio has completed playing the tone
00162 // from MMdaAudioToneObserver
00163 void CMediaClientEngine::MatoPlayComplete(TInt aError)
00164         {
00165         __ASSERT_DEBUG(iState == ETonePlaying, Panic(CMediaClientEngine::ENotReady));
00166         __ASSERT_DEBUG(iEngineObserver, Panic(CMediaClientEngine::ENullObserver));
00167         
00168         // Tell observer sound is complete, and clean up
00169         ToneCleanup();
00170         iEngineObserver -> HandleEngineState(iState,aError);
00171         }
00172 
00173 // Clean up
00174 void CMediaClientEngine::ToneCleanup()
00175         {
00176         iState = EIdle;
00177         delete iAudioToneUtility;
00178         iAudioToneUtility = NULL;
00179         }
00180 
00181 
00182 //
00183 /************** SOUND FILE PLAYING ******************/
00184 //
00185 
00186 // Play a sound file
00187 void CMediaClientEngine::PlayL(const TDesC &aFile)
00188         {
00189         __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00190         
00191         iAudioPlayUtility = CMdaAudioPlayerUtility::NewFilePlayerL(aFile, *this);
00192         iState = EPlayFilePrepare;
00193         // This will call back MapcInitComplete() when preparation is complete
00194         }
00195 
00196 // Audio is now prepared to play a file
00197 // from MMdaAudioPlayerCallback
00198 void CMediaClientEngine::MapcInitComplete(TInt aError, 
00199                                                                                   const TTimeIntervalMicroSeconds& /*aDuration*/)
00200         {
00201         __ASSERT_DEBUG(iEngineObserver, Panic(CMediaClientEngine::ENullObserver));
00202         __ASSERT_DEBUG(iAudioPlayUtility, Panic(CMediaClientEngine::ENullPlayerUtility));
00203         __ASSERT_DEBUG(iState == EPlayFilePrepare || iState == EGetMetaData1, Panic(CMediaClientEngine::EWrongState));
00204         
00205         // If preparation was sucessful, play the tone
00206         if (aError)
00207                 {
00208                 PlayCleanup();
00209                 iEngineObserver -> HandleEngineState(iState,aError);
00210                 return;
00211                 }
00212         if (iState == EPlayFilePrepare)
00213                 {
00214                 iState = EPlayFilePlaying;
00215                 iAudioPlayUtility -> SetVolume(iAudioPlayUtility -> MaxVolume()/iVolume);
00216                 iAudioPlayUtility->Play();              
00217                 iEngineObserver -> HandleEngineState(iState,aError);
00218                 return;
00219                 }
00220         if (iState == EGetMetaData1)
00221                 {
00222                 TInt numEntries = 0;
00223                 iAudioPlayUtility -> GetNumberOfMetaDataEntries(numEntries);
00224                 for (TInt i=0; i<numEntries; i++)
00225                         {
00226                         CMMFMetaDataEntry *dataEntry=CMMFMetaDataEntry::NewL();
00227                         TRAPD(err,dataEntry = iAudioPlayUtility->GetMetaDataEntryL(i));
00228                         if(err)
00229                                 {
00230                                 return;
00231                                 }
00232                         iMetaData->Append(dataEntry);
00233                         }
00234                 PlayCleanup();
00235                 iEngineObserver -> HandleEngineState(EGetMetaData2,aError);
00236                 iState = EIdle;
00237                 return;
00238                 }
00239         }
00240 
00241 // Audio has completed playing the tone
00242 // from MMdaAudioPlayerCallback
00243 void CMediaClientEngine::MapcPlayComplete(TInt aError)
00244         {
00245         __ASSERT_DEBUG(iState == EPlayFilePlaying, Panic(CMediaClientEngine::ENotReady));
00246         __ASSERT_DEBUG(iEngineObserver, Panic(CMediaClientEngine::ENullObserver));
00247         
00248         // Tell observer sound is complete, and clean up
00249         PlayCleanup();
00250         iEngineObserver -> HandleEngineState(iState,aError);
00251         }
00252 
00253 // Clean up
00254 void CMediaClientEngine::PlayCleanup()
00255         {
00256         iState = EIdle;
00257         delete iAudioPlayUtility;
00258         iAudioPlayUtility = NULL;
00259         }
00260 
00261 
00262 //
00263 /************** SOUND RECORDING/CONVERSION ******************/
00264 //
00265 
00266 // Get a list of possible record formats
00267 void CMediaClientEngine::RecordTypesL(CDesCArray& aTypeArray)
00268         {
00269         // get a list of mmf plug-ins that can read the file's format
00270         RMMFControllerImplInfoArray controllers;
00271         CleanupResetAndDestroyPushL(controllers);
00272 
00273         CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();
00274         CMMFFormatSelectionParameters* fSelectRead = CMMFFormatSelectionParameters::NewLC();
00275         CMMFFormatSelectionParameters* fSelectWrite = CMMFFormatSelectionParameters::NewLC();
00276 
00277         RArray<TUid> mediaIds;
00278         mediaIds.Append(KUidMediaTypeAudio);
00279         CleanupClosePushL(mediaIds);
00280         cSelect->SetMediaIdsL(mediaIds, CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds);
00281         cSelect->SetRequiredPlayFormatSupportL(*fSelectRead);
00282         cSelect->SetRequiredRecordFormatSupportL(*fSelectWrite); // need to specify this as otherwise the supported record formats won't be retrieved
00283         cSelect->ListImplementationsL(controllers);
00284 
00285         TBuf<10> buf;
00286         // Loop through each returned plug-in and get their record formats
00287         for (TInt i=0; i<controllers.Count(); i++)
00288                 {
00289                 const RMMFFormatImplInfoArray& recordInfo =  controllers[i]->RecordFormats();
00290                 // Get array of supported file extensions.
00291                 for (TInt j=0; j<recordInfo.Count(); j++)
00292                         {
00293                         const CDesC8Array& extensions = recordInfo[j]->SupportedFileExtensions();
00294                         // and finally add each extension to the array
00295                         for (TInt k=0; k<extensions.Count(); k++)
00296                                 {
00297                                 buf.Copy(extensions[k]);
00298                                 aTypeArray.AppendL(buf);
00299                                 } // end of k
00300                         } // end of j
00301                 } // end of i
00302         CleanupStack::PopAndDestroy(5);
00303         } // end of function
00304 
00305 
00306 // Record into a file
00307 void CMediaClientEngine::RecordL(const TDesC &aFile, const TRecordFormatOptions& aRecordFormatOptions)
00308         {
00309         __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00310         
00311         iRecordFormatOptions = &aRecordFormatOptions;
00312         // Set up file to record to, the recording format, codec, and settings
00313         iAudioRecorderUtility = CMdaAudioRecorderUtility::NewL(*this);
00314         iAudioRecorderUtility -> OpenFileL(aFile);
00315         iState = ERecordPrepare;
00316         iEngineObserver -> HandleEngineState(iState,KErrNone);
00317         // This will call back MoscoStateChangeEvent() when preparation is complete
00318         }
00319 
00320 // Set options and start recording
00321 void CMediaClientEngine::Record2L()
00322         {
00323         // Set the options
00324         iAudioRecorderUtility -> SetAudioDeviceMode(CMdaAudioRecorderUtility::EDefault);
00325         if (iRecordFormatOptions->iGainSet)
00326                 iAudioRecorderUtility -> SetGain(iRecordFormatOptions->iGain);
00327         if (iRecordFormatOptions->iBalanceSet)
00328                 iAudioRecorderUtility -> SetPlaybackBalance(iRecordFormatOptions->iBalance);
00329         if (iRecordFormatOptions->i4CCSet)
00330                 iAudioRecorderUtility -> SetDestinationDataTypeL(iRecordFormatOptions->i4CC);
00331         if (iRecordFormatOptions->iBitRateSet)
00332                 iAudioRecorderUtility -> SetDestinationBitRateL(iRecordFormatOptions->iBitRate);
00333         if (iRecordFormatOptions->iSampleRateSet)
00334                 iAudioRecorderUtility -> SetDestinationSampleRateL(iRecordFormatOptions->iSampleRate);
00335         if (iRecordFormatOptions->iChannelSet)
00336                 iAudioRecorderUtility -> SetDestinationNumberOfChannelsL(iRecordFormatOptions->iChannel);
00337 
00338         // and start recording
00339         iAudioRecorderUtility -> RecordL();
00340         iState = ERecording;
00341         }
00342 
00343 // Clean up recorder
00344 void CMediaClientEngine::RecordCleanup()
00345         {
00346         iState = EIdle;
00347         delete iAudioRecorderUtility;
00348         iAudioRecorderUtility = NULL;
00349         }
00350 
00351 // Gets a recorder for specified target type
00352 CMdaAudioRecorderUtility* CMediaClientEngine::NewRecorderL(const TDesC& aTargetType)
00353         {
00354         __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00355 
00356         return CRecorderCreator::NewRecorderL(aTargetType);
00357         }
00358 
00359 // ************** CRecorderCreator **************
00360 //
00361 
00362 CRecorderCreator::CRecorderCreator()
00363 :CActive(EPriorityStandard)
00364         {}
00365 
00366 CMdaAudioRecorderUtility* CRecorderCreator::NewRecorderL(const TDesC& aTargetType)
00367         {
00368         CRecorderCreator* creator = new (ELeave) CRecorderCreator();
00369         CleanupStack::PushL(creator);
00370         CMdaAudioRecorderUtility* record = creator->ConstructL(aTargetType);
00371         CleanupStack::PopAndDestroy(creator);
00372         return record;
00373         }
00374 
00375 CMdaAudioRecorderUtility* CRecorderCreator::ConstructL(const TDesC& aTargetType)
00376         {
00377         _LIT(KDummyName, "\\dummy");
00378         TFileName name(KDummyName);
00379         name.Append(aTargetType);
00380 
00381         // create converter
00382         iRecorderUtility = CMdaAudioRecorderUtility::NewL(*this);
00383         iRecorderUtility->OpenFileL(name);
00384         CActiveScheduler::Add(this);
00385         SetActive();
00386         CActiveScheduler::Start();
00387         return iRecorderUtility;
00388         }
00389 
00390 void CRecorderCreator::RunL()
00391         {
00392         if (iStatus != KErrNone)
00393                 {
00394                 delete iRecorderUtility;
00395                 iRecorderUtility = NULL;
00396                 }
00397         CActiveScheduler::Stop();
00398         }
00399 
00400 void CRecorderCreator::DoCancel()
00401         {
00402         delete iRecorderUtility;
00403         iRecorderUtility = NULL;
00404         CActiveScheduler::Stop();
00405         }
00406 
00407 void CRecorderCreator::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, 
00408         TInt /*aCurrentState*/, TInt aErrorCode)
00409         {
00410         TRequestStatus* status = &iStatus;
00411         User::RequestComplete(status, aErrorCode);
00412         }
00413 
00414 // Record/convert events handler
00415 // from MMdaObjectStateChangeObserver
00416 void CMediaClientEngine::MoscoStateChangeEvent(CBase* aObject, 
00417                 TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode)
00418         {
00419         __ASSERT_ALWAYS(aObject == iAudioRecorderUtility || aObject == iConvertUtility, Panic(CMediaClientEngine::EWrongState));
00420         if (aObject == iAudioRecorderUtility)
00421                 {
00422                 __ASSERT_DEBUG(iState == CMediaClientEngine::ERecordPrepare || iState == CMediaClientEngine::ERecording, 
00423                         Panic(CMediaClientEngine::EWrongState));
00424 
00425                 if (aErrorCode)
00426                         RecordCleanup();
00427                 else if (aCurrentState == CMdaAudioClipUtility::EOpen)
00428                         {
00429                         TRAPD(err,Record2L());
00430                         if(err)
00431                                 {
00432                                 return;
00433                                 }
00434                         }
00435                 iEngineObserver -> HandleEngineState(iState,aErrorCode);
00436                 }
00437         // Handle converter event
00438         if (aObject == iConvertUtility)
00439                 {
00440                 __ASSERT_DEBUG(iState == CMediaClientEngine::EConvert || iState == CMediaClientEngine::EConvertComplete, 
00441                         Panic(CMediaClientEngine::EWrongState));
00442                 // converter has finished
00443                 if (aErrorCode || iState == CMediaClientEngine::EConvertComplete)
00444                         ConvertCleanup();
00445                 else // converter has opened file, move to next stage
00446                         {
00447                         TRAPD(err,Convert2L());
00448                         if(err)
00449                                 {
00450                                 return;
00451                                 }
00452                         }
00453                 iEngineObserver -> HandleEngineState(iState,aErrorCode);
00454                 }
00455         }
00456 
00457 // Get a list of possible destination types
00458 void CMediaClientEngine::DestinationTypesL(const TFileName& aFile, CDesCArray& aTypeArray)
00459         {
00460         // get a list of mmf plug-ins that can read the file's format
00461         RMMFControllerImplInfoArray controllers;
00462         CleanupResetAndDestroyPushL(controllers);
00463         CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();
00464         CMMFFormatSelectionParameters* fSelectRead = CMMFFormatSelectionParameters::NewLC();
00465         CMMFFormatSelectionParameters* fSelectWrite = CMMFFormatSelectionParameters::NewLC();
00466         fSelectRead->SetMatchToFileNameL(aFile); // Specify the source file format
00467         cSelect->SetRequiredPlayFormatSupportL(*fSelectRead);
00468         cSelect->SetRequiredRecordFormatSupportL(*fSelectWrite); // need to specify this as otherwise the supported record formats won't be retrieved
00469         cSelect->ListImplementationsL(controllers);
00470 
00471         TBuf<10> buf;
00472         TParsePtrC parse(aFile);
00473         TPtrC ext = parse.Ext();
00474 
00475         // Loop through each returned plug-in and get their record formats
00476         for (TInt i=0; i<controllers.Count(); i++)
00477                 {
00478                 const RMMFFormatImplInfoArray& recordInfo =  controllers[i]->RecordFormats();
00479                 // Get array of supported file extensions.
00480                 for (TInt j=0; j<recordInfo.Count(); j++)
00481                         {
00482                         const CDesC8Array& extensions = recordInfo[j]->SupportedFileExtensions();
00483                         // and finally add each extension to the array
00484                         for (TInt k=0; k<extensions.Count(); k++)
00485                                 {
00486                                 buf.Copy(extensions[k]);
00487                                 if (buf != ext)
00488                                         aTypeArray.AppendL(buf);
00489                                 } // end of k
00490                         } // end of j
00491                 } // end of i
00492         CleanupStack::PopAndDestroy(4);
00493         } // end of function
00494 
00495 // Create and open a converter
00496 void CMediaClientEngine::ConvertL(const TFileName& aFile, const TDesC& aTargetType, const TFormatOptions& aOptions)
00497         {
00498         __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00499         
00500         iOptions = &aOptions;
00501         ChangeExtension(aFile, aTargetType, iTargetFile);
00502         // create converter
00503         iConvertUtility = CMdaAudioConvertUtility::NewL(*this);
00504         iConvertUtility->OpenL(aFile, iTargetFile);
00505         iState = EConvert;
00506         // This will call back MoscoStateChangeEvent() when converter is open
00507         }
00508 
00509 // Set conversion options and start conversion
00510 void CMediaClientEngine::Convert2L()
00511         {
00512         if (iOptions->i4CCSet) iConvertUtility->SetDestinationDataTypeL(iOptions->i4CC);
00513         if (iOptions->iBitRateSet) iConvertUtility->SetDestinationBitRateL(iOptions->iBitRate);
00514         if (iOptions->iSampleRateSet) iConvertUtility->SetDestinationSampleRateL(iOptions->iSampleRate);
00515         if (iOptions->iChannelSet) iConvertUtility->SetDestinationNumberOfChannelsL(iOptions->iChannel);
00516         iConvertUtility->ConvertL();
00517         iState = EConvertComplete;
00518         // This will call back MoscoStateChangeEvent() when conversion is complete
00519         }
00520 
00521 // Clean up converter
00522 void CMediaClientEngine::ConvertCleanup()
00523         {
00524         iState = EIdle;
00525         delete iConvertUtility;
00526         iConvertUtility = NULL;
00527         }
00528 
00529 //
00530 /************** STREAM PLAYING ******************/
00531 //
00532 
00533 // Play a stream
00534 void CMediaClientEngine::PlayL()
00535         {
00536         __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00537         iAudioStreamPlayer = CMdaAudioOutputStream::NewL(*this);
00538         iSettings.iVolume = iAudioStreamPlayer -> MaxVolume()/iVolume;
00539         iSettings.iChannels = TMdaAudioDataSettings::EChannelsMono;
00540         iSettings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz;
00541 
00542         iAudioStreamPlayer -> Open(&iSettings);
00543                 // indicates whether the example will use a list to store the sound fragments
00544         iState = EStreamPrepare;
00545         iEngineObserver -> HandleEngineState(iState,KErrNone);
00546         // This will call back MaoscOpenComplete() when preparation is complete
00547         }
00548 
00549 // Audio is now prepared to play a stream
00550 void CMediaClientEngine::MaoscOpenComplete(TInt aError)
00551         {
00552         if (aError)
00553                 StreamCleanup();
00554         else
00555                 iState = EStreamStarted;
00556 
00557         iEngineObserver -> HandleEngineState(iState,aError);
00558         }
00559 
00560 // Audio has accepted data: call back observer so they know to write more data.
00561 // If using a list, just delete the first element
00562 void CMediaClientEngine::MaoscBufferCopied(TInt aError, const TDesC8& /*aBuffer*/)
00563         {
00564         // Check for error
00565         if (aError)
00566                 iState = EStreamError;
00567         else
00568                 iState = ENextStreamBuf;
00569 
00570         iEngineObserver -> HandleEngineState(iState,aError);
00571         }
00572 
00573 // Stream has finished
00574 void CMediaClientEngine::MaoscPlayComplete(TInt aError)
00575         {
00576         if (aError == KErrUnderflow) aError=KErrNone;
00577         StreamCleanup();
00578         iEngineObserver -> HandleEngineState(iState,aError);
00579         }
00580 
00581 // Write data to the stream
00582 void CMediaClientEngine::WriteToStreamL(const TDesC8& aData)
00583         {
00584         if (iState == CMediaClientEngine::EStreamStarted 
00585                 || iState == CMediaClientEngine::ENextStreamBuf) 
00586                 iAudioStreamPlayer -> WriteL(aData);
00587         // This will call back MaoscBufferCopied() when the data is copied
00588         }
00589 
00590 
00591 // Clean up
00592 void CMediaClientEngine::StreamCleanup()
00593         {
00594         iState = EIdle;
00595         delete iAudioStreamPlayer;
00596         iAudioStreamPlayer = NULL;
00597         }
00598 
00599 
00600 //
00601 // ************** METADATA FOR A FILE **************
00602 //
00603 
00604 void CMediaClientEngine::GetMetaDataL(const TFileName& aFile, RMetaDataArray& aMetaData)
00605         {
00606         __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00607         
00608         iAudioPlayUtility = CMdaAudioPlayerUtility::NewFilePlayerL(aFile, *this);
00609         iMetaData = &aMetaData;
00610         iState = EGetMetaData1;
00611         // This will call back MapcInitComplete() when preparation is complete
00612         }
00613 
00614 
00615 // Helper classes & functions
00616 
00617 //
00618 // ************** CConverterCreator **************
00619 //
00620 
00621 CMdaAudioConvertUtility* CMediaClientEngine::NewConverterL(const TFileName& aFile, const TDesC& aTargetType,
00622         TFileName& aTargetFile)
00623         {
00624         __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00625 
00626         return CConverterCreator::NewConverterL(aFile, aTargetType, aTargetFile);
00627         }
00628 
00629 CConverterCreator::CConverterCreator()
00630 :CActive(EPriorityStandard)
00631         {}
00632 
00633 CMdaAudioConvertUtility* CConverterCreator::NewConverterL(const TFileName& aFile, const TDesC& aTargetType,
00634         TFileName& aTargetFile)
00635         {
00636         CConverterCreator* creator = new (ELeave) CConverterCreator();
00637         CleanupStack::PushL(creator);
00638         CMdaAudioConvertUtility* convert = creator->ConstructL(aFile, aTargetType, aTargetFile);
00639         CleanupStack::PopAndDestroy(creator);
00640         return convert;
00641         }
00642 
00643 CMdaAudioConvertUtility* CConverterCreator::ConstructL(const TFileName& aFile, const TDesC& aTargetType,
00644         TFileName& aTargetFile)
00645         {
00646         ChangeExtension(aFile, aTargetType, aTargetFile);
00647         // create converter
00648         iConvertUtility = CMdaAudioConvertUtility::NewL(*this);
00649         iConvertUtility->OpenL(aFile, aTargetFile);
00650         CActiveScheduler::Add(this);
00651         SetActive();
00652         CActiveScheduler::Start();
00653         return iConvertUtility;
00654         }
00655 
00656 void CConverterCreator::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt /*aCurrentState*/, TInt aErrorCode)
00657         {
00658         TRequestStatus* status = &iStatus;
00659         User::RequestComplete(status, aErrorCode);
00660         }
00661 
00662 void CConverterCreator::RunL()
00663         {
00664         if (iStatus != KErrNone)
00665                 {
00666                 delete iConvertUtility;
00667                 iConvertUtility = NULL;
00668                 }
00669         CActiveScheduler::Stop();
00670         }
00671 
00672 void CConverterCreator::DoCancel()
00673         {
00674         delete iConvertUtility;
00675         iConvertUtility = NULL;
00676         CActiveScheduler::Stop();
00677         }
00678 
00679 //
00680 // ************* ChangeExtension *************
00681 //
00682 
00683 void ChangeExtension(const TFileName& aFile, const TDesC& aTargetType,
00684         TFileName& aTargetFile)
00685         {
00686         // create target file name as existing file + plus target extension
00687         aTargetFile = aFile;
00688         TParsePtr parse(aTargetFile);
00689         TPtrC ext = parse.Ext();
00690         aTargetFile.Replace(aTargetFile.Length()-ext.Length(),ext.Length(),aTargetType);
00691         }

Generated on Thu Jan 21 10:32:59 2010 for TB10.1 Example Applications by  doxygen 1.5.3