FCL/sf/incubator/stemkit: comparison breakdeps/mmfclientaudioplayer.cpp

equal deleted inserted replaced

-:8338c5c25b5b
+:4a58d534bdaa
 #include <bautils.h>
 #include <utf.h>
 #include <mmf/common/mmfpaniccodes.h>
 #include "mmfclientaudioplayer.h"
-#include "mmfclientutility.h"
+//#include "mmfclientutility.h"
 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
-#include <mmf/common/mmfdurationinfocustomcommandsimpl.h>
+//#include <mmf/common/mmfdurationinfocustomcommandsimpl.h>
-#include <mmf/common/mmfdurationinfocustomcommandsenums.h>
+//#include <mmf/common/mmfdurationinfocustomcommandsenums.h>
 #endif
 using namespace ContentAccess;
 // declared in the recorder module
 */
 EXPORT_C void CMdaAudioPlayerUtility::OpenFileL(const RFile& aFile)
 	{
 	ASSERT(iProperties);
 	RFile& file = const_cast<RFile&>(aFile);
-	TMMFileHandleSource tfs(file, KDefaultContentObject, EPlay);
+	//TMMFileHandleSource tfs(file, KDefaultContentObject, EPlay);
-	iProperties->OpenFileL(tfs);
+	TMMFileHandleSource * tfs;
+	iProperties->OpenFileL(*tfs);
 	}
 /**
 Opens an audio clip from a file.
 																		CMdaServer* /*aServer*/)
 	{
 	CMMFMdaAudioPlayerUtility* self = new(ELeave) CMMFMdaAudioPlayerUtility(aCallback, aPriority, aPref);
 	CleanupStack::PushL(self);
 	self->ConstructL();
-	TMMFileSource filesource(aFileName, KDefaultContentObject, EPlay);
+	//TMMFileSource filesource(aFileName, KDefaultContentObject, EPlay);
-	self->OpenFileL(filesource);
+	TMMFileSource * filesource;
+	self->OpenFileL(*filesource);
 	CleanupStack::Pop(self);
 	return self;
 	}
 CMMFMdaAudioPlayerUtility* CMMFMdaAudioPlayerUtility::NewDesPlayerL(const TDesC8& aData, MMdaAudioPlayerCallback& aCallback, TInt aPriority, TInt aPref, CMdaServer* /*aServer*/)
 	return self;
 	}
 void CMMFMdaAudioPlayerUtility::UseSharedHeap()
 	{
-	iFindAndOpenController->UseSharedHeap();
+	//iFindAndOpenController->UseSharedHeap();
 	}
 // CMMFMdaAudioPlayerUtility
 CMMFMdaAudioPlayerUtility::~CMMFMdaAudioPlayerUtility()
 	{
-	delete iControllerImplementationInformation;
+	//delete iControllerImplementationInformation;
 	delete iAsyncCallBack;
-	delete iRepeatTrailingSilenceTimer;
+	//delete iRepeatTrailingSilenceTimer;
-	delete iFindAndOpenController;
+	//delete iFindAndOpenController;
-	delete iControllerEventMonitor;
+	//delete iControllerEventMonitor;
-	iMediaIds.Close();
+	//iMediaIds.Close();
-	iController.Close();
+	//iController.Close();
 	}
 CMMFMdaAudioPlayerUtility::CMMFMdaAudioPlayerUtility(MMdaAudioPlayerCallback& aCallback, TInt aPriority, TInt aPref) :
-	iCallback(aCallback),
+CTimer(EPriorityHigh),
-	iAudioPlayDeviceCommands(iController),
+	iCallback(aCallback)
-	iAudioPlayControllerCommands(iController),
+//	iAudioPlayDeviceCommands(iController),
-	iNotificationRegistrationCommands(iController),
+//	iAudioPlayControllerCommands(iController),
-	iDRMCustomCommands(iController),
+//	iNotificationRegistrationCommands(iController)
-	iAudioPlayControllerSetRepeatsCommands(iController)
+//	iDRMCustomCommands(iController)
+//	iAudioPlayControllerSetRepeatsCommands(iController)
 	{
 	iState = EStopped;
 	iPrioritySettings.iPriority = aPriority;
 	iPrioritySettings.iPref = aPref;
 	iPlayStart = TTimeIntervalMicroSeconds(0);
 	iEventHolder = KNullUid;
 	}
 void CMMFMdaAudioPlayerUtility::ConstructL()
 	{
-	iControllerEventMonitor = CMMFControllerEventMonitor::NewL(*this, iController);
+	//iControllerEventMonitor = CMMFControllerEventMonitor::NewL(*this, iController);
-	iRepeatTrailingSilenceTimer = CRepeatTrailingSilenceTimer::NewL(*this);
+	//iRepeatTrailingSilenceTimer = CRepeatTrailingSilenceTimer::NewL(*this);
 	iAsyncCallBack = CMMFMdaAudioPlayerCallBack::NewL(iCallback);
-	User::LeaveIfError(iMediaIds.Append(KUidMediaTypeAudio));
+	//User::LeaveIfError(iMediaIds.Append(KUidMediaTypeAudio));
-	iFindAndOpenController = CMMFFindAndOpenController::NewL(*this);
+	//iFindAndOpenController = CMMFFindAndOpenController::NewL(*this);
-	iFindAndOpenController->Configure(iMediaIds[0], iPrioritySettings);
+	//iFindAndOpenController->Configure(iMediaIds[0], iPrioritySettings);
-	iFindAndOpenController->ConfigureController(iController, *iControllerEventMonitor, CMMFFindAndOpenController::EPlayback);
+	//iFindAndOpenController->ConfigureController(iController, *iControllerEventMonitor, CMMFFindAndOpenController::EPlayback);
-	}
+	iAsyncCallBack->InitComplete(KErrNone, 500000);
+	}
+#if 0
 void CMMFMdaAudioPlayerUtility::MfaocComplete(
 		TInt& aError,
 		RMMFController* /*aController*/,
 		TUid aControllerUid,
 		TMMFMessageDestination* /*aSourceHandle*/,
 			}
 		}
 	iAsyncCallBack->InitComplete(aError, iDuration);
 	}
+#endif
 /**
 	Open an audio clip from a file
 	@param "const TFileSource& aFileSource" "the file to open"
 	@leave "" "Leaves on an error opening the file
 	@since version 5.0
 */
 void CMMFMdaAudioPlayerUtility::OpenFileL(const TDesC& aFileName)
 	{
-	TMMFileSource filesource(aFileName, KDefaultContentObject, EPlay);
+	//TMMFileSource filesource(aFileName, KDefaultContentObject, EPlay);
-	OpenFileL(filesource);
+	TMMFileSource * filesource;
+	OpenFileL(*filesource);
 	}
 /**
 	Open an audio clip from a file
 	@param "const RFile& aFile" "the shared session file handle to open"
 	@since version 5.0
 */
 void CMMFMdaAudioPlayerUtility::OpenFileL(const RFile& aFile)
 	{
 	RFile& file = const_cast<RFile&>(aFile);
-	TMMFileHandleSource filesource(file, KDefaultContentObject, EPlay);
+	//TMMFileHandleSource filesource(file, KDefaultContentObject, EPlay);
-	OpenFileL(filesource);
+	TMMFileHandleSource * filesource;
+	OpenFileL(*filesource);
 	}
 void CMMFMdaAudioPlayerUtility::OpenFileL(const TMMSource& aSource)
 	{
 	// If iAsyncCallBack is already active, we're still in the process of notifying the client
 	// that a previous request to Open...(...) has completed.
 	if (iAsyncCallBack->IsActive())
 		User::Leave(KErrNotReady);
+#if 0
 	if (aSource.SourceType()==KUidMMFileHandleSource)
 		{
 		RFile& fileHandle = static_cast<const TMMFileHandleSource&>(aSource).Handle();
 		iFindAndOpenController->ConfigureSourceSink(
 			TMMFileHandleSource(fileHandle, aSource.UniqueId(), aSource.Intent(), aSource.IsUIEnabled()),
 			TMMFileSource(fileName, aSource.UniqueId(), aSource.Intent(), aSource.IsUIEnabled()),
 			CMMFFindAndOpenController::TSourceSink(KUidMmfAudioOutput));
 		}
 	iFindAndOpenController->OpenByFileSource(aSource);
+#endif
 	}
 /**
 	Open an audio clip from a descriptor
 	@param "const TDesC8& aDescriptor" "the descriptor containing the clip"
 	{
 	// If iAsyncCallBack is already active, we're still in the process of notifying the client
 	// that a previous request to Open...(...) has completed.
 	if (iAsyncCallBack->IsActive())
 		User::Leave(KErrInUse);
+#if 0
 	iFindAndOpenController->ConfigureSourceSink(
 		CMMFFindAndOpenController::TSourceSink(KUidMmfDescriptorSource,
 													CMMFFindAndOpenController::GetConfigDescriptor(aDescriptor)),
 		CMMFFindAndOpenController::TSourceSink(KUidMmfAudioOutput));
 	iFindAndOpenController->OpenByDescriptor(aDescriptor);
+#endif
 	}
 /**
 	Open an audio clip from a Url
 	@param "const TDesC& aUrl" "the url reference to the clip"
 	{
 	// If iAsyncCallBack is already active, we're still in the process of notifying the client
 	// that a previous request to Open...(...) has completed.
 	if (iAsyncCallBack->IsActive())
 		User::Leave(KErrInUse);
+#if 0
 	CBufFlat* urlCfgBuffer = NULL;
 	CMMFFindAndOpenController::GetConfigUrlL(urlCfgBuffer, aUrl, aIapId);
 	iFindAndOpenController->ConfigureSourceSink(
 		CMMFFindAndOpenController::TSourceSink(KUidMmfUrlSource, urlCfgBuffer->Ptr(0)),
 		CMMFFindAndOpenController::TSourceSink(KUidMmfAudioOutput));
 	iFindAndOpenController->OpenByUrl(aUrl, aIapId, aMimeType);
 	delete urlCfgBuffer;
+#endif
 	}
 /**
 Begins playback of the initialised audio sample at the current volume
 and priority levels.
 if (iState == EPlaying)
 		{
 		iAsyncCallBack->PlayComplete(KErrNotReady);
 		return;
 		}
+#if 0
 	// cancel the repeat timer in case the client has called Play()
 	// without waiting for the previous play to complete
 	iRepeatTrailingSilenceTimer->Cancel();
 	// Reset played count
 	if(iState != EPaused)
 				}
 			//Controller not supporting setrepeats custom command is not a real error
 			//we revert back to playerutility's loop play implementation in that case
 			}
 		}
+#endif
 	DoPlay();
 	}
 void CMMFMdaAudioPlayerUtility::DoPlay()
 	{
+#if 0
 #if defined(__AUDIO_PROFILING)
 	RDebug::ProfileStart(4);
 #endif  // defined(__AUDIO_PROFILING)
 TInt err = KErrNone;
 if (iState != EPaused || iRepeatCancelled)
 			{
 			iController.Stop();
 			iAsyncCallBack->PlayComplete(err);
 			}
 		}
+#endif
+	iState = EPlaying;
+	After(500000);
 	}
 /**
 Stops playback of the audio sample as soon as possible.
 	if (iState==EPlaying || iState==EPaused)
 		{
 		// cancel the repeat timer in case the client has called Stop()
 		// during the trailing silence period
-		iRepeatTrailingSilenceTimer->Cancel();
+		//iRepeatTrailingSilenceTimer->Cancel();
-		iController.Stop();
+		//iController.Stop();
 		iPosition = iPlayStart;
 		iState = EStopped;
 		}
 	}
 * @since	7.0s
 */
 TInt CMMFMdaAudioPlayerUtility::Pause()
 	{
 	TInt err = KErrNone;
+#if 0
 	if(iRepeatTrailingSilenceTimer->IsActive())
 		{
 		iRepeatTrailingSilenceTimer->Cancel();
 		iRepeatCancelled = ETrue;
 		iState = EPaused;
 		err = iController.Pause();
 		if (!err || err==KErrNotReady)
 			err = iController.GetPosition(iPosition);
 		iState = EPaused;
 		}
+#endif
+	iState = EPaused;
 	return err;
 	}
 /**
 *
 */
 void CMMFMdaAudioPlayerUtility::Close()
 	{
 	// Reset the audio player state.
 	Stop();
+#if 0
 	iControllerEventMonitor->Cancel();
 	iController.Close();
 	if (iFindAndOpenController)
 		iFindAndOpenController->Close();
 	if(iControllerImplementationInformation)
 		{
 		delete iControllerImplementationInformation;
 		iControllerImplementationInformation = NULL;
 		}
 	iControllerUid = KNullUid;
-	}
+#endif
+	}
+void CMMFMdaAudioPlayerUtility::RunL()
+	{
+	switch(iState)
+		{
+		case EPlaying:
+			iAsyncCallBack->PlayComplete(KErrNone);
+			break;
+		default:
+			// do nothing
+			break;
+		}
+	}
 /**
 Changes the current playback volume to a specified value.
 The volume can be changed before or during playback and is effective
 immediately.
 @since  5.0
 */
 TInt CMMFMdaAudioPlayerUtility::SetVolume(TInt aVolume)
 	{
+	TInt err = KErrNone;
+#if 0
 	TInt err = iAudioPlayDeviceCommands.SetVolume(aVolume);
 	if (err == KErrArgument)
 		{
 		TInt maxVolume = MaxVolume();
 		if (aVolume < 0)
 			{
 			aVolume = maxVolume;
 			}
 		err = iAudioPlayDeviceCommands.SetVolume(aVolume);
 		}
+#endif
 	return err;
 	}
 /**
 Sets the number of times the audio sample is to be repeated during the
 		Negative values will produce a panic USER 87.
 @since	5.0
 */
 void CMMFMdaAudioPlayerUtility::SetRepeats(TInt aRepeatNumberOfTimes, const TTimeIntervalMicroSeconds& aTrailingSilence)
 	{
+#if 0
 	TInt err = iAudioPlayControllerSetRepeatsCommands.SetRepeats(aRepeatNumberOfTimes, aTrailingSilence);
 	if(err!=KErrNone)
 		{
 		iNumberOfTimesToRepeat = aRepeatNumberOfTimes;
 		iTrailingSilence = aTrailingSilence;
 		}
+#endif
 	}
 /**
 Defines the period over which the volume level is to rise smoothly
 from nothing to the normal volume level.
 @since  5.0
 */
 void CMMFMdaAudioPlayerUtility::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration)
 	{
-	iAudioPlayDeviceCommands.SetVolumeRamp(aRampDuration);
+	//iAudioPlayDeviceCommands.SetVolumeRamp(aRampDuration);
 	}
 TInt CMMFMdaAudioPlayerUtility::SetPriority(TInt aPriority, TInt aPref)
 	{
+	return KErrNone;
+#if 0
 	iPrioritySettings.iPref = aPref;
 	iPrioritySettings.iPriority = aPriority;
 	iFindAndOpenController->Configure(iMediaIds[0], iPrioritySettings);
 	return iController.SetPrioritySettings(iPrioritySettings);
+#endif
 	}
 /**
 Returns the duration of the audio sample.
 @since  5.0
 */
 const TTimeIntervalMicroSeconds& CMMFMdaAudioPlayerUtility::Duration()
 	{
+#if 0
 	TInt err = iController.GetDuration(iDuration);
 	if (err)
 		{
 		iDuration = 0;
 		}
+#endif
+	iDuration = 500000;
 	return iDuration;
 	}
 /**
 Returns the duration of the audio sample in microseconds, and the duration state.
 @since	9.1
 */
 TMMFDurationInfo CMMFMdaAudioPlayerUtility::Duration(TTimeIntervalMicroSeconds& aDuration)
 {
+#if 0
 	TPckgBuf<TMMFDurationInfo> pckg;
 	TMMFDurationInfo result = EMMFDurationInfoValid;
 	TMMFMessageDestinationPckg iDestinationPckg(TMMFMessageDestination(KUidInterfaceMMFDurationInfoControl, KMMFObjectHandleController));
 	// Get the duration information to return in aDuration
 	// This is the intended behaviour regardless of what value err has
 	aDuration = Duration();
 	return result;
+#endif
+	return EMMFDurationInfoValid;
 }
 /**
 Returns an integer representing the maximum volume.
 @since  5.0
 */
 TInt CMMFMdaAudioPlayerUtility::MaxVolume()
 	{
-	TInt maxVolume = 0;
+	TInt maxVolume = 100;
+#if 0
 #ifdef _DEBUG
 	TInt error =
 #endif
 		iAudioPlayDeviceCommands.GetMaxVolume(maxVolume);
 	__ASSERT_DEBUG(error==KErrNone, Panic(EMMFMediaClientPanicServerCommunicationProblem));
+#endif
 	return maxVolume;
 	}
+#if 0
 void CMMFMdaAudioPlayerUtility::HandleEvent(const TMMFEvent& aEvent)
 	{
 	// handle loading started/complete messages first, as the later code does not explicitly check the event type
 	if (aEvent.iEventType == KMMFEventCategoryAudioLoadingStarted)
 		{
 			}
 		}
 	// else we have an unexpected event that cannot be dealt with by the client.
 	// We will simply ignore this.
 	}
+#endif
 void CMMFMdaAudioPlayerUtility::PlaySilence()
 	{
+#if 0
 	// iRepeatTrailingSilenceTimer->After() takes a TTimeIntervalMicroSeconds32
 	// so for longer periods of silence call it repeatedly with KMaxTInt lengths
 	TTimeIntervalMicroSeconds32 silence;
 	if (iTrailingSilenceLeftToPlay.Int64() > KMaxTInt)
 		{
 		{
 		silence = I64INT(iTrailingSilenceLeftToPlay.Int64());
 		iTrailingSilenceLeftToPlay = 0;
 		}
 	iRepeatTrailingSilenceTimer->After(silence);
-	}
+#endif
+	}
+#if 0
 void CMMFMdaAudioPlayerUtility::RepeatTrailingSilenceTimerComplete()
 	{
 	if (iTrailingSilenceLeftToPlay.Int64() > 0)
 		{
 		PlaySilence();
 		// reset the position for subsequent plays
 		iPosition = iPlayStart;
 		DoPlay();
 		}
 	}
+#endif
 /**
 *
 * Returns the current playback position in microseconds
 *
 */
 TInt CMMFMdaAudioPlayerUtility::GetPosition(TTimeIntervalMicroSeconds& aPosition)
 	{
 	TInt error = KErrNone;
 	if (iState==EPlaying)
-		error = iController.GetPosition(iPosition);
+		aPosition = 250000;
+//		error = iController.GetPosition(iPosition);
 	aPosition = iPosition;
 	return error;
 	}
 /**
 *
 * @since	7.0s
 */
 void CMMFMdaAudioPlayerUtility::SetPosition(const TTimeIntervalMicroSeconds& aPosition)
 	{
+#if 0
 	// Clip the position if aPosition is greater than the duration
 	// or if aPosition is negative.
 	const TTimeIntervalMicroSeconds maxPosition(Duration());
 	const TTimeIntervalMicroSeconds minPosition(0);
 		}
 //	else if (iState == EPaused)
 //		{
 //		Stop();	// We call stop so that DevSound's internal buffers are reset
 //		}
+#endif
 	}
 /**
 Returns the current playback volume
 @since  7.0s
 */
 TInt CMMFMdaAudioPlayerUtility::GetVolume(TInt& aVolume)
 	{
+#if 0
 	TInt error = iAudioPlayDeviceCommands.GetVolume(aVolume);
 	return error;
+#endif
+	aVolume = 50;
+	return KErrNone;
 	}
 /**
 *
 * Returns the number of meta data entries in the current clip
 *
 * @since	7.0s
 */
 TInt CMMFMdaAudioPlayerUtility::GetNumberOfMetaDataEntries(TInt& aNumEntries)
 	{
+#if 0
 	TInt error = iController.GetNumberOfMetaDataEntries(aNumEntries);
 	return error;
+#endif
+	aNumEntries = 0;
+	return KErrNone;
 	}
 /**
 *
 * Returns the requested meta data entry
 *
 * @since	7.0s
 */
 CMMFMetaDataEntry* CMMFMdaAudioPlayerUtility::GetMetaDataEntryL(TInt aMetaDataIndex)
 	{
+#if 0
 	return iController.GetMetaDataEntryL(aMetaDataIndex);
+#endif
+	User::Leave(KErrNotSupported);
+	return NULL;
 	}
 /**
 *
 * Set the current playback window
 */
 TInt CMMFMdaAudioPlayerUtility::SetPlayWindow(const TTimeIntervalMicroSeconds& aPlayStart,
 											  const TTimeIntervalMicroSeconds& aPlayEnd)
 	{
 	TInt error = KErrNone;
+#if 0
 	if (aPlayStart >= TTimeIntervalMicroSeconds(0) &&
 		aPlayStart < iDuration &&
 			aPlayStart < aPlayEnd &&
 			aPlayEnd <= iDuration )
 		{
 		if (iState==EPlaying)
 			error = iAudioPlayControllerCommands.SetPlaybackWindow(aPlayStart, aPlayEnd);
 		}
 	else
 		error = KErrArgument;
+#endif
 	return error;
 	}
 /**
 *
 */
 TInt CMMFMdaAudioPlayerUtility::ClearPlayWindow()
 	{
 	// clear play window start - very important because this is assigned
 	// to iPosition when we stop & is used to set the position on the next Play()
-	iPosition = iPlayStart = iPlayEnd = TTimeIntervalMicroSeconds(0);
+	//iPosition = iPlayStart = iPlayEnd = TTimeIntervalMicroSeconds(0);
-	iPlayWindowSet = EClear;
+	//iPlayWindowSet = EClear;
 	TInt err = KErrNone;
-	if (iState==EPlaying)
+	//if (iState==EPlaying)
-		err = iAudioPlayControllerCommands.DeletePlaybackWindow();
+		//err = iAudioPlayControllerCommands.DeletePlaybackWindow();
 	return err;
 	}
 /**
 Sets the current playback balance
 @since  7.0s
 */
 TInt CMMFMdaAudioPlayerUtility::SetBalance(TInt aBalance)
 	{
-	TInt err = iAudioPlayDeviceCommands.SetBalance(aBalance);
+	//TInt err = iAudioPlayDeviceCommands.SetBalance(aBalance);
-	return err;
+	//return err;
+	return KErrNone;
 	}
 /**
 Returns the bit rate of the audio clip.
 @since  7.0s
 */
 TInt CMMFMdaAudioPlayerUtility::GetBitRate(TUint& aBitRate)
 	{
-	RMMFAudioControllerCustomCommands controller(iController);
+	//RMMFAudioControllerCustomCommands controller(iController);
-	TInt err = controller.GetSourceBitRate(aBitRate);
+	//TInt err = controller.GetSourceBitRate(aBitRate);
-	return err;
+	//return err;
+	return KErrNone;
 	}
 const CMMFControllerImplementationInformation& CMMFMdaAudioPlayerUtility::ControllerImplementationInformationL()
 	{
+#if 0
 	if (!iControllerImplementationInformation)
 		{
 		if (iControllerUid==KNullUid)
 			User::Leave(KErrNotReady);
 		iControllerImplementationInformation = CMMFControllerImplementationInformation::NewL(iControllerUid);
 		}
 	return *iControllerImplementationInformation;
+#endif
+	User::Leave(KErrNotSupported);
+	return *iControllerImplementationInformation;
 	}
 void CMMFMdaAudioPlayerUtility::GetAudioLoadingProgressL(TInt& aPercentageProgress)
 	{
-	User::LeaveIfError(iAudioPlayControllerCommands.GetLoadingProgress(aPercentageProgress));
+	//User::LeaveIfError(iAudioPlayControllerCommands.GetLoadingProgress(aPercentageProgress));
+	User::Leave(KErrNotSupported);
 	}
 TInt CMMFMdaAudioPlayerUtility::CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom)
 	{
-	return iController.CustomCommandSync(aDestination, aFunction, aDataTo1, aDataTo2, aDataFrom);
+	//return iController.CustomCommandSync(aDestination, aFunction, aDataTo1, aDataTo2, aDataFrom);
+	return KErrNotSupported;
 	}
 TInt CMMFMdaAudioPlayerUtility::CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2)
 	{
-	return iController.CustomCommandSync(aDestination, aFunction, aDataTo1, aDataTo2);
+	//return iController.CustomCommandSync(aDestination, aFunction, aDataTo1, aDataTo2);
+	return KErrNotSupported;
 	}
 void CMMFMdaAudioPlayerUtility::CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus)
 	{
-	iController.CustomCommandAsync(aDestination, aFunction, aDataTo1, aDataTo2, aDataFrom, aStatus);
+	//iController.CustomCommandAsync(aDestination, aFunction, aDataTo1, aDataTo2, aDataFrom, aStatus);
 	}
 void CMMFMdaAudioPlayerUtility::CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus)
 	{
-	iController.CustomCommandAsync(aDestination, aFunction, aDataTo1, aDataTo2, aStatus);
+	//iController.CustomCommandAsync(aDestination, aFunction, aDataTo1, aDataTo2, aStatus);
 	}
 /**
 Returns the current playback balance
 @since  7.0s
 */
 TInt CMMFMdaAudioPlayerUtility::GetBalance(TInt& aBalance)
 	{
-	TInt err = iAudioPlayDeviceCommands.GetBalance(aBalance);
+	//TInt err = iAudioPlayDeviceCommands.GetBalance(aBalance);
-	return err;
+	//return err;
+	aBalance = KMMFBalanceMaxLeft;
+	return KErrNone;
 	}
 MMMFDRMCustomCommand* CMMFMdaAudioPlayerUtility::GetDRMCustomCommand()
 	{
+#if 0
 	// TODO: check controller supports MMMFDRMCustomCommandImplementor
 	if (iDRMCustomCommands.IsSupported())
 		{
 		return static_cast<MMMFDRMCustomCommand*>(&iDRMCustomCommands);
 		}
 	else
 		{
 		return NULL;
 		}
+#endif
+	return NULL;
 	}
 void CMMFMdaAudioPlayerUtility::RegisterForAudioLoadingNotification(MAudioLoadingObserver& aLoadingObserver)
 	{
 	iLoadingObserver = &aLoadingObserver;
 TInt CMMFMdaAudioPlayerUtility::RegisterAudioResourceNotification(MMMFAudioResourceNotificationCallback& aCallback,
 																	TUid aNotificationEventUid,
 																	const TDesC8& aNotificationRegistrationData)
 	{
+#if 0
 	iAudioResourceNotificationCallBack = &aCallback;
 	TInt err = iNotificationRegistrationCommands.RegisterAsClient(aNotificationEventUid, aNotificationRegistrationData);
 	if(err == KErrNotReady)
 		{
 		iEventHolder = 	aNotificationEventUid;
 		return KErrNone;
 		}
 	iNotificationDataHolder = KNullDesC8;
 	iEventHolder = KNullUid;
 	return err;
+#endif
+	return KErrNotSupported;
 	}
 TInt CMMFMdaAudioPlayerUtility::CancelRegisterAudioResourceNotification(TUid aNotificationEventId)
 	{
+#if 0
 	TInt err = iNotificationRegistrationCommands.CancelRegisterAsClient(aNotificationEventId);
 	if(err == KErrNotReady)
 		{
 		if(aNotificationEventId != KMMFEventCategoryAudioResourceAvailable)
 			{
 		iEventHolder = KNullUid;
 		iNotificationDataHolder = KNullDesC8;
 		return KErrNone;
 		}
 	return err;
+#endif
+	return KErrNotSupported;
 	}
 TInt CMMFMdaAudioPlayerUtility::WillResumePlay()
 	{
-	return iNotificationRegistrationCommands.WillResumePlay();
+	//return iNotificationRegistrationCommands.WillResumePlay();
+	return KErrNone;
 	}
 TInt CMMFMdaAudioPlayerUtility::SetThreadPriority(const TThreadPriority& aThreadPriority) const
 	{
-	return iController.SetThreadPriority(aThreadPriority);
+	//return iController.SetThreadPriority(aThreadPriority);
+	return KErrNone;
 	}
 CRepeatTrailingSilenceTimer* CRepeatTrailingSilenceTimer::NewL(MRepeatTrailingSilenceTimerObs& aObs)
 	{
 	CRepeatTrailingSilenceTimer* s = new(ELeave) CRepeatTrailingSilenceTimer(aObs);

changeset 129	4a58d534bdaa
parent 128	8338c5c25b5b