FCL/sf/app/internetradio: comparison qtinternetradio/irqmediaplayer/src/irqmmfadapter.cpp

equal deleted inserted replaced

-:5723da102db1
+:38bbf2dcd608
 IRQMMFAdapter::IRQMMFAdapter() :
 iVideoPlayer(NULL)
 ,iQMetaData(NULL)
 ,iPrepareTimer(NULL), iStereoEffect(NULL)
 {
+LOG_METHOD;
 iPlayState = EStopped;
 }
 // ---------------------------------------------------------------------------
 //  IRQMMFAdapter::~IRQMMFAdapter
 //  Clean up resources
 // ---------------------------------------------------------------------------
 //
 IRQMMFAdapter::~IRQMMFAdapter()
 {
+LOG_METHOD;
 destroyPlayer();
 delete iQMetaData;
 iQMetaData = NULL;
 {
 LOG_METHOD;
 TRAPD(error, playL(aUrl, aApId));
 if (NULL == iQMetaData)
 {
+LOG("Error Occured(EIRQErrorOutOfMemory)");
 emit errorOccured(EIRQErrorOutOfMemory);
 }
 if (KErrNone != error)
 {
+LOG_FORMAT("Error Occured = %d", (int)error);
 emit errorOccured(EIRQPlayerErrorGeneral);
 }
 }
 // ---------------------------------------------------------------------------
 //  Play url via specific access point id
 // ---------------------------------------------------------------------------
 //
 void IRQMMFAdapter::playL(const QString &aUrl, int aApId)
 {
+LOG_METHOD;
 // Save stream Url
 if (NULL == iQMetaData)
 {
 iQMetaData = new (ELeave) IRQMetaData();
 }
 // If the status is not stopped, clean up last playback resources
 stop();
 // Open url
+LOG("CVideoPlayerUtility::OpenUrlL(stationUrl, aApId, KNullDesC8, KUidController)");
 iVideoPlayer->OpenUrlL(stationUrl, aApId, KNullDesC8, KUidController);
 iPlayState = EOpenning;
 }
 // ---------------------------------------------------------------------------
 //  Stop playback, call Close() to clean up allocated resources
 // ---------------------------------------------------------------------------
 //
 void IRQMMFAdapter::stop()
 {
+LOG_METHOD;
 if (iVideoPlayer && EStopped != iPlayState)
 {
+LOG("Stop the prepare timeout timer");
 if (iPrepareTimer)
 {
 if (iPrepareTimer->IsActive())
 {
 iPrepareTimer->Cancel();
 }
 }
+LOG("CVideoPlayerUtility::Stop()");
+LOG("CVideoPlayerUtility::Close()");
 iVideoPlayer->Stop();
 iVideoPlayer->Close();
 iPlayState = EStopped;
 }
 }
 // ---------------------------------------------------------------------------
 //
 void IRQMMFAdapter::setVolume(int aVolume)
 {
 LOG_METHOD;
 if (iVideoPlayer && iPlayState > EOpenning)
 {
 // aVolume is a percentage
 if (aVolume < KVolumeMinPercentage)
 {
 {
 aVolume = KVolumeMaxPercentage;
 }
 int volume = aVolume*iVideoPlayer->MaxVolume()/KVolumeMaxPercentage;
+LOG_FORMAT("CVideoPlayerUtility::SetVolumeL(%d)", volume);
 TRAPD(error, iVideoPlayer->SetVolumeL(volume));
 if (KErrNone != error)
 {
+LOG_FORMAT("Error Occured = %d", (int)error);
 emit errorOccured(EIRQPlayerErrorGeneral);
 }
 }
 }
 //  Get current volume value from player
 // ---------------------------------------------------------------------------
 //
 int IRQMMFAdapter::getVolume()
 {
+LOG_METHOD;
 int volume = KVolumeMinPercentage;
 if (iVideoPlayer && iPlayState > EOpenning)
 {
 // Return a percentage
 return (void*)iVideoPlayer;
 }
 void IRQMMFAdapter::enableStereoEffect()
 {
+LOG_METHOD;
 if (IRQPlayerAdapterInterface::EPlaying != iPlayState)
 {
 return;
 }
 TRAP_IGNORE(enableStereoEffectL());
 }
 void IRQMMFAdapter::disableStereoEffect()
 {
+LOG_METHOD;
 if (iStereoEffect)
 {
 if (iStereoEffect->IsEnabled())
 {
 TRAPD(error, iStereoEffect->DisableL());
 if (KErrNone != error)
 {
+LOG_FORMAT("Error Occured = %d", (int)error);
 emit errorOccured(EIRQPlayerErrorSetStereoFailed);
 }
 delete iStereoEffect;
 iStereoEffect = NULL;
 }
 return;
 }
 }
 // Prepare to playback
+LOG("CVideoPlayerUtility::Prepare()");
 iVideoPlayer->Prepare();
 iPlayState = EConnecting;
 // Start a timer to check preparation status
 if (iPrepareTimer->IsActive())
 iPrepareTimer->Cancel();
 }
 TTimeIntervalMicroSeconds32 interval(KConnectingTime);
 iPrepareTimer->Start(interval,interval,
 TCallBack(IRQMMFAdapter::isPrepareCompleted,this));
+LOG_FORMAT("Start the prepare timeout timer = %d sec", (int)interval.Int()/1000000);
 }
 else
 {
+LOG_FORMAT("Error Occured = %d", (int)aError);
 emit errorOccured(EIRQPlayerErrorConnectingFailed);
 }
 }
 // ---------------------------------------------------------------------------
 //
 void IRQMMFAdapter::MvpuoPrepareComplete(TInt aError)
 {
 LOG_METHOD;
 // Cancel the previous request if pending
+LOG("Stop the prepare timeout timer");
 if (iPrepareTimer->IsActive())
 {
 iPrepareTimer->Cancel();
 }
 {
 iQMetaData->setBitrate(bitrate/1000);
 }
 // Send signal ConnectionEstablished
+LOG_FORMAT("bit rate = %d", iQMetaData->getBitrate());
 emit connectionEstablished(iQMetaData->getBitrate());
 // Set specific event to get meta data from player
 setMetadataEventConfig();
 // Start playback
+LOG("CVideoPlayerUtility::Play()");
 iVideoPlayer->Play();
 iPlayState = EBuffering;
 }
 else if (KErrServerBusy == aError)
 {
+LOG("Error Occured(EIRQPlayerErrorServerFull)");
 emit errorOccured(EIRQPlayerErrorServerFull);
 }
 else
 {
+LOG_FORMAT("Error Occured = %d", (int)aError);
 emit errorOccured(EIRQPlayerErrorConnectingFailed);
 }
 }
 // ---------------------------------------------------------------------------
 void IRQMMFAdapter::MvpuoPlayComplete(TInt aError)
 {
 LOG_METHOD;
 if (KErrNone != aError)
 {
+LOG_FORMAT("Error Occured = %d", (int)aError);
 emit errorOccured(EIRQPlayerErrorGeneral);
 }
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 void IRQMMFAdapter::MvpuoEvent(TMMFEvent const & aEvent)
 {
 LOG_METHOD;
-LOG_FORMAT( "aevent is %d", (int)aEvent);
 if (KMMFEventCategoryVideoPlayerGeneralError == aEvent.iEventType)
 {
+LOG("Event Type = KMMFEventCategoryVideoPlayerGeneralError");
 switch (aEvent.iErrorCode)
 {
 case KErrHardwareNotAvailable:
+LOG("Event Error Code = KErrHardwareNotAvailable");
+emit errorOccured(EIRQPlayerErrorAudioDeviceLost);
+break;
 case KErrMMAudioDevice:
 // Higher priority application has taken over the
 // audio device. --> Do stop.
+LOG("Event Error Code = KErrMMAudioDevice");
 emit errorOccured(EIRQPlayerErrorAudioDeviceLost);
 break;
 case KErrDisconnected:
+LOG("Event Error Code = KErrDisconnected");
 emit errorOccured(EIRQPlayerErrorConnectionLost);
 break;
 case KErrTimedOut:
+LOG("Event Error Code = KErrTimedOut");
 emit errorOccured(EIRQPlayerErrorTimeOut);
 break;
 case KErrServerBusy:
+LOG("Event Error Code = KErrServerBusy");
 emit errorOccured(EIRQPlayerErrorServerFull);
 break;
 default:
+LOG_FORMAT("Event Error Code = %d", (int)aEvent.iErrorCode);
 emit errorOccured(EIRQPlayerErrorGeneral);
 break;
 }
 }
 else if (KMMFRefreshMetaData == aEvent.iEventType)
 {
+LOG("Event Type = KMMFRefreshMetaData");
+LOG_FORMAT( "Event Error Code = %d", (int)aEvent.iErrorCode);
 // Get refreshed meta data
 TRAPD(error, getRefreshedMetaDataL(aEvent.iErrorCode));
 if (KErrNone != error)
 {
+LOG_FORMAT("Get MetaData Error Occured = %d", (int)error);
 emit errorOccured(EIRQPlayerErrorGeneral);
 }
+}
+else
+{
+LOG_FORMAT("Event Type = %d", (int)aEvent.iEventType.iUid);
+LOG_FORMAT("Event Error Code = %d", (int)aEvent.iErrorCode);
 }
 }
 // ---------------------------------------------------------------------------
 //  IRQMMFAdapter::MvpuoFrameReady
 //  For video stream only, never called
 // ---------------------------------------------------------------------------
 //
 void IRQMMFAdapter::MvpuoFrameReady(CFbsBitmap& aFrame,TInt aError)
 {
+LOG_METHOD;
 Q_UNUSED(aFrame);
 Q_UNUSED(aError);
 }
 // ---------------------------------------------------------------------------
 {
 LOG_METHOD;
 // Get buffering progress and send it to application
 int percentageComplete = 0;
+LOG("CVideoPlayerUtility::GetVideoLoadingProgressL()");
 TRAPD(error, iVideoPlayer->GetVideoLoadingProgressL(percentageComplete));
 if (KErrNone == error)
 {
 // Send signal to UpdateProgress
+LOG_FORMAT("Loading Percentage Complete = %d", percentageComplete);
 emit percentageBuffered(percentageComplete);
 }
 else
 {
+LOG_FORMAT("Error Occured = %d", (int)error);
 emit errorOccured(EIRQPlayerErrorGeneral);
 }
 }
 // ---------------------------------------------------------------------------
 void IRQMMFAdapter::getRefreshedMetaDataL(TInt index)
 {
 LOG_METHOD;
 if (iQMetaData)
 {
+LOG("CVideoPlayerUtility::MetaDataEntryL()");
 CMMFMetaDataEntry* pMetadataEntry = iVideoPlayer->MetaDataEntryL(index);
 QString entryName = QString::fromUtf16(pMetadataEntry->Name().Ptr(),
 pMetadataEntry->Name().Length());
 //  Create player instance
 // ---------------------------------------------------------------------------
 //
 void IRQMMFAdapter::createPlayerL()
 {
+LOG_METHOD;
+LOG("CVideoPlayerUtility::NewL()");
 // Create player instance
 iVideoPlayer = CVideoPlayerUtility2::NewL(*this,KAudioPriorityAudioPlaybackStreaming ,
 (TMdaPriorityPreference)KAudioPrefRealOneStreaming);
+LOG("CVideoPlayerUtility::RegisterForVideoLoadingNotification()");
 // Register loading notification
 iVideoPlayer->RegisterForVideoLoadingNotification(*this);
 }
 // ---------------------------------------------------------------------------
 //  Destroy player
 // ---------------------------------------------------------------------------
 //
 void IRQMMFAdapter::destroyPlayer()
 {
+LOG_METHOD;
 delete iVideoPlayer;
 iVideoPlayer = NULL;
 }
 // ---------------------------------------------------------------------------
 //  Enable meta data event
 // ---------------------------------------------------------------------------
 //
 void IRQMMFAdapter::setMetadataEventConfig()
 {
+LOG_METHOD;
 TMMFMessageDestinationPckg  destinationPckg(KUidInterfaceMMFControllerMetadataEventMsg);
 TPckgBuf<TBool>             metadataEventPckg(EMMFEnableMetadataEvent);
 //  Enable meta data event.
+LOG("CVideoPlayerUtility::CustomCommandSync(EMMFSetMetadataEventConfig)");
 iVideoPlayer->CustomCommandSync(destinationPckg,
 EMMFSetMetadataEventConfig,
 metadataEventPckg,
 KNullDesC8);
 }
 //  Static function for periodic call
 // ---------------------------------------------------------------------------
 //
 TInt IRQMMFAdapter::isPrepareCompleted(TAny* aPtr)
 {
+LOG_METHOD;
+LOG("Prepare timeout timer call back function");
 IRQMMFAdapter* self = static_cast<IRQMMFAdapter*>(aPtr);
 if (self)
 {
 self->checkPrepare();
 }
 // ---------------------------------------------------------------------------
 //
 void IRQMMFAdapter::checkPrepare()
 {
 LOG_METHOD;
+LOG("Stop the prepare timeout timer");
 if (iPrepareTimer->IsActive())
 {
 // Cancel the previous request if pending
 iPrepareTimer->Cancel();
 }
 if (EConnecting == iPlayState)
 {
+LOG("Error Occured(EIRQPlayerErrorConnectingFailed)");
 emit errorOccured(EIRQPlayerErrorConnectingFailed);
 stop();
 }
 }

changeset 17	38bbf2dcd608
parent 14	896e9dbc5f19