FCL/sf/mw/mmmw: comparison khronosfws/openmax_al/src/mmf_adaptation/cmmfradiobackendengine.cpp

equal deleted inserted replaced

-:c2e43643db4c
+:4ce423f34688
 #include "cmmfradiobackendengine.h"
 extern "C" {
 #include "xaradioitfadaptation.h"
-#include "xanokiavolumeextitfadaptationmmf.h"
+#include "xaadaptationmmf.h"
-#include "xanokialinearvolumeitfadaptationmmf.h"
+#include "xaadptbasectx.h"
-#include "xaplayitfadaptationmmf.h"
 }
 CMMFRadioBackendEngine *CMMFRadioBackendEngine::s_instance = 0;
 CMMFRadioBackendEngine* CMMFRadioBackendEngine::Instance()
 }
 void CMMFRadioBackendEngine::DeleteInstance()
 {
 if (iFmTunerUtility)
 {
 iFmTunerUtility->Close();
 iFmTunerUtility = NULL;
 }
 if (iRadioPlayerUtility)
 {
 iRadioPlayerUtility->Close();
 iRadioPlayerUtility = NULL;
 }
 if (iRadioUtility)
 {
 delete iRadioUtility;
 iRadioUtility = NULL;
 }
 }
 CMMFRadioBackendEngine::~CMMFRadioBackendEngine()
 {
 }
 iFmTunerUtility = &iRadioUtility->RadioFmTunerUtilityL( *this );
 }
 if (iFmTunerUtility)
 {
 iFmTunerUtility->EnableTunerInOfflineMode( ETrue );
 iFmTunerUtility->RequestTunerControl();
 }
 if (iRadioUtility)
 {
 iRadioPlayerUtility = &iRadioUtility->RadioPlayerUtilityL( *this );
 }
 SetForceMonoFlag();
 iDefaultFrequency = RADIO_DEFAULT_FREQ;
 iDefaultFreqRange = (TFmRadioFrequencyRange)RADIO_DEFAULT_FREQ_RANGE;
 iDefaultMinFreq = RADIO_DEFAULT_MIN_FREQ;
 iDefaultMaxFreq = RADIO_DEFAULT_MAX_FREQ;
-}
+iAdaptContext = (XAAdaptationBaseCtx*)CMMFRadioBackendEngine::Instance();
-void CMMFRadioBackendEngine::StationSeek(XAboolean aUpwards)
-{
+}
-if (iFmTunerUtility)
+void CMMFRadioBackendEngine::StationSeek(TBool aUpwards)
 {
-iFmTunerUtility->StationSeek(aUpwards);
+if (iFmTunerUtility)
+{
+iFmTunerUtility->StationSeek(aUpwards);
 }
 }
 void CMMFRadioBackendEngine::SetFrequency(TInt aFreq)
 {
-DEBUG_API_A1("CMMFRadioBackendEngine::SetFrequency: %d", aFreq);
+//  DEBUG_CPP_API_A1("CMMFRadioBackendEngine::SetFrequency: %d", aFreq);
 if (iFmTunerUtility)
 {
 iFmTunerUtility->SetFrequency(aFreq);
 }
 }
 TInt CMMFRadioBackendEngine::GetFrequency(TInt& aFreq)
 {
-DEBUG_API("CMMFRadioBackendEngine::GetFrequency");
+//    DEBUG_CPP_API("CMMFRadioBackendEngine::GetFrequency");
 TInt ret = KErrNotFound;
 if (iFmTunerUtility)
 {
 ret = iFmTunerUtility->GetFrequency(aFreq);
 if (ret != KErrNone)
 {
 aFreq = iDefaultFrequency;
 ret = KErrNone;
 }
 }
-DEBUG_API_A1("CMMFRadioBackendEngine::GetFrequency RET: %d", ret);
+//  DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetFrequency RET: %d", ret);
-//  RDebug::Print(_L("CMMFRadioBackendEngine::GetFrequency RET: %d"), ret);
 return ret;
 }
 TInt CMMFRadioBackendEngine::GetSignalStrength(TInt& aSignalStrength)
 {
 TInt ret = KErrNotFound;
 if (iFmTunerUtility)
 {
 ret = iFmTunerUtility->GetSignalStrength(aSignalStrength);
 }
-DEBUG_API_A1("CMMFRadioBackendEngine::GetSignalStrength RET: %d", ret);
+//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetSignalStrength RET: %d", ret);
 //  RDebug::Print(_L("CMMFRadioBackendEngine::GetSignalStrength RET: %d"), ret);
 return ret;
 }
 void CMMFRadioBackendEngine::CancelSetFrequency()
 maxFreq = iDefaultMaxFreq;
 aRange = iDefaultFreqRange;
 ret = KErrNone;
 }
 }
-DEBUG_API_A1("CMMFRadioBackendEngine::GetFreqRange RET: %d", ret);
+//   DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetFreqRange RET: %d", ret);
-//  RDebug::Print(_L("CMMFRadioBackendEngine::GetFreqRange RET: %d"), ret);
+return ret;
-return ret;
 }
 TInt CMMFRadioBackendEngine::GetFreqRangeProperties(TFmRadioFrequencyRange& aRange, TInt& aMinFreq, TInt& aMaxFreq)
 {
 TInt ret = KErrNotFound;
 if (iFmTunerUtility)
 {
 ret = iFmTunerUtility->GetFrequencyRange((TFmRadioFrequencyRange&)aRange, (TInt&)aMinFreq, (TInt&)aMaxFreq);
 if (ret != KErrNone)
 {
 aMinFreq = iDefaultMinFreq;
 aMaxFreq = iDefaultMaxFreq;
 ret = KErrNone;
 }
 }
-DEBUG_API_A1("CMMFRadioBackendEngine::GetFreqRangeProperties RET: %d", ret);
+//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetFreqRangeProperties RET: %d", ret);
-//  RDebug::Print(_L("CMMFRadioBackendEngine::GetFreqRangeProperties RET: %d"), ret);
+return ret;
-return ret;
 }
 TInt CMMFRadioBackendEngine::GetMaxVolume(TInt& aMaxVol)
 {
 TInt ret = KErrNotFound;
 if (iRadioPlayerUtility)
 {
 ret = iRadioPlayerUtility->GetMaxVolume(aMaxVol);
 }
 return ret;
 }
 TInt CMMFRadioBackendEngine::SetVolume(TInt aVol)
 {
 TInt ret = KErrNotFound;
 if (iRadioPlayerUtility)
 {
 ret = iRadioPlayerUtility->SetVolume(aVol);
 }
 return ret;
 }
-TInt CMMFRadioBackendEngine::SetMute(XAboolean aMute)
+TInt CMMFRadioBackendEngine::SetMute(TBool aMute)
 {
 TInt ret = KErrNotFound;
 if (iRadioPlayerUtility)
 {
 ret = iRadioPlayerUtility->Mute(aMute);
 }
 return ret;
 }
 TInt CMMFRadioBackendEngine::GetVolume(TInt& aVol)
 {
 TInt ret = KErrNotFound;
 if (iRadioPlayerUtility)
 {
 ret = iRadioPlayerUtility->GetVolume(aVol);
 }
 return ret;
 }
-TInt CMMFRadioBackendEngine::GetForcedMonoReception(XAuint32& aForcedMono)
+TInt CMMFRadioBackendEngine::GetForcedMonoReception(TUint& aForcedMono)
 {
 TInt ret = KErrNotFound;
 TBool forceMono(EFalse);
 if (iFmTunerUtility)
 {
 aForcedMono = XA_STEREOMODE_AUTO; // Radio Utility Default value
 return KErrNone;
 }
 }
 if (forceMono)
 {
 aForcedMono = XA_STEREOMODE_MONO;
 }
 if (iForceStereo)
 aForcedMono = XA_STEREOMODE_STEREO;
 else
 aForcedMono = XA_STEREOMODE_AUTO;
 }
 return ret;
 }
 void CMMFRadioBackendEngine::PlayRadio()
 {
 if (iRadioPlayerUtility)
 {
 iRadioPlayerUtility->Stop();
 }
 }
-TInt CMMFRadioBackendEngine::ForceMonoReception(XAuint32 aForcedMono)
+TInt CMMFRadioBackendEngine::ForceMonoReception(TUint aForcedMono)
 {
 TInt ret = KErrNotFound;
-XAuint32 currentMode;
+TUint currentMode;
 ret = GetForcedMonoReception(currentMode);
 if (ret != XA_RESULT_SUCCESS)
 return ret;
 {
 ret = iFmTunerUtility->ForceMonoReception(EFalse);
 }
 }
 }
-DEBUG_API_A1("CMMFRadioBackendEngine::ForceMonoReception RET: %d", ret);
+//   DEBUG_CPP_API_A1("CMMFRadioBackendEngine::ForceMonoReception RET: %d", ret);
-// RDebug::Print(_L("CMMFRadioBackendEngine::ForceMonoReception RET: %d"), ret);
+return ret;
-return ret;
+}
-}
+XAresult CMMFRadioBackendEngine::SetForceMonoFlag()
-XAresult CMMFRadioBackendEngine::SetForceMonoFlag()
+{
-{
+TInt ret = KErrNotFound;
-TInt ret = KErrNotFound;
+TBool forceMono;
-TBool forceMono(EFalse);
 if (iFmTunerUtility)
 {
 ret = iFmTunerUtility->GetForcedMonoReception(forceMono);
 if (ret == KErrNotReady)
 {
 // For Radio Utility Default value = XA_STEREOMODE_STEREO
 iForceStereo = ETrue;
 return KErrNone;
 }
+}
-}
 if (forceMono == XA_STEREOMODE_MONO)
 {
 iForceStereo = EFalse;
 }
 else
 {
 iForceStereo = ETrue;
 }
 return ret;
 }
-XAresult CMMFRadioBackendEngine::SetRadioAdaptContext(void * adaptcontext)
-{
+TInt CMMFRadioBackendEngine::GetSquelch(TBool& aSquelch)
-iRadioAdaptContext = adaptcontext;
+{
-return XA_RESULT_SUCCESS;
+TInt ret = KErrNotFound;
-}
+if (iFmTunerUtility)
+{
-XAresult CMMFRadioBackendEngine::SetPlayerAdaptContext(void * adaptcontext)
+ret = iFmTunerUtility->GetSquelch(aSquelch);
-{
+}
-iPlayerAdaptContext = adaptcontext;
+return ret;
-return XA_RESULT_SUCCESS;
+}
+TInt CMMFRadioBackendEngine::SetSquelch(TBool aSquelch)
+{
+TInt ret = KErrNotFound;
+if (iFmTunerUtility)
+{
+ret = iFmTunerUtility->SetSquelch(aSquelch);
+}
+return ret;
+}
+void CMMFRadioBackendEngine::SetAdaptContext(void * adaptcontext)
+{
+iAdaptContext = (XAAdaptationBaseCtx*)adaptcontext;
 }
 XAresult TranslateError(TInt error)
 {
 XAresult status(XA_RESULT_SUCCESS);
 {
 case KErrNone:
 status = XA_RESULT_SUCCESS;
 break;
 // to do: investigate and add other possible errors:
 /* case XA_RESULT_PRECONDITIONS_VIOLATED:
 break;
 case XA_RESULT_PARAMETER_INVALID:
 break;
 case XA_RESULT_MEMORY_FAILURE:
 break;
 case XA_RESULT_RESOURCE_ERROR:
 break;
 case XA_RESULT_RESOURCE_LOST:
 break;
 case XA_RESULT_IO_ERROR:
 break;
 case XA_RESULT_BUFFER_INSUFFICIENT:
 break;
 case XA_RESULT_CONTENT_CORRUPTED:
 break;
 case XA_RESULT_CONTENT_UNSUPPORTED:
 break;
 case XA_RESULT_CONTENT_NOT_FOUND:
 break;
 case XA_RESULT_PERMISSION_DENIED:
 case XA_RESULT_CONTROL_LOST:
 break;
 */
 default:
-break;
+	break;
 } // end switch
 return status;
 }
 // -----------------------------------------------------------------------------
 // CMMFRadioBackendEngine::MrpeoPresetChanged
 // CMMFRadioBackendEngine::MrftoSquelchChange
 //
 // ----------------------------------------------------
 //
 void CMMFRadioBackendEngine::MrftoSquelchChange(
-TBool /*aSquelch*/ )
+TBool aSquelch)
 {
+//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoSquelchChange: aSquelch =  %d", aSquelch);
+// Currently, Openmaxal doesn't have event defined to handle this callback
 }
 // ----------------------------------------------------
 // CMMFRadioBackendEngine::MrftoForcedMonoChanged
 // Called when a client enables/disabled forced mono reception
 // ----------------------------------------------------
 //
 void CMMFRadioBackendEngine::MrftoForcedMonoChange(
 TBool aForcedMono )
 {
-DEBUG_API_A1("CMMFRadioBackendEngine::MrftoForcedMonoChange: aForcedMono =  %d", aForcedMono);
+//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoForcedMonoChange: aForcedMono =  %d", aForcedMono);
-//  RDebug::Print(_L("CMMFRadioBackendEngine::MrftoForcedMonoChange: aForcedMono = %d"), aForcedMono);
+XARadioItfAdapt_StereoStatusChange((XAAdaptationBaseCtx*)iAdaptContext, aForcedMono);
-XARadioItfAdapt_StereoStatusChange((XAAdaptationBaseCtx*)iRadioAdaptContext, aForcedMono);
 }
 // ----------------------------------------------------
 // CMMFRadioBackendEngine::MrftoFrequencyChange
 // Called when the tuned frequency changes
 // ----------------------------------------------------
 //
 void CMMFRadioBackendEngine::MrftoFrequencyChange(
 TInt aNewFrequency)
 {
-DEBUG_API_A1("CMMFRadioBackendEngine::MrftoFrequencyChange: aNewFrequency =  %d", aNewFrequency);
+//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoFrequencyChange: aNewFrequency =  %d", aNewFrequency);
-// RDebug::Print(_L("CMMFRadioBackendEngine::MrftoFrequencyChange aNewFrequency = %d"), aNewFrequency);
+XARadioItfAdapt_FrequencyChange((XAAdaptationBaseCtx*)iAdaptContext, aNewFrequency);
-XARadioItfAdapt_FrequencyChange((XAAdaptationBaseCtx*)iRadioAdaptContext, aNewFrequency);
 }
 // ----------------------------------------------------
 // CMMFRadioBackendEngine::MrftoFrequencyRangeChange
 //
 // ----------------------------------------------------
 //
 void CMMFRadioBackendEngine::MrftoFrequencyRangeChange(
 TFmRadioFrequencyRange aNewRange )
 {
-DEBUG_API_A1("CMMFRadioBackendEngine::MrftoFrequencyRangeChange: aNewRange =  %d", aNewRange);
+//   DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoFrequencyRangeChange: aNewRange =  %d", aNewRange);
-//  RDebug::Print(_L("CMMFRadioBackendEngine::MrftoFrequencyRangeChange: aNewRange = %d"), aNewRange);
+XARadioItfAdapt_FrequencyRangeChange((XAAdaptationBaseCtx*)iAdaptContext, aNewRange);
-XARadioItfAdapt_FrequencyRangeChange((XAAdaptationBaseCtx*)iRadioAdaptContext, aNewRange);
 }
 // ----------------------------------------------------
 // CMMFRadioBackendEngine::MrftoOfflineModeStatusChange
 // Called when offline mode status changes
 //
 void CMMFRadioBackendEngine::MrftoStationSeekComplete(
 TInt aError,
 TInt aFrequency )
 {
-XARadioItfAdapt_SeekComplete((XAAdaptationBaseCtx*)iRadioAdaptContext, aError, aFrequency);
+XARadioItfAdapt_SeekComplete((XAAdaptationBaseCtx*)iAdaptContext, aError, aFrequency);
 }
 // ----------------------------------------------------
 // CMMFRadioBackendEngine::MrftoSetFrequencyComplete
 // ----------------------------------------------------
 //
 void CMMFRadioBackendEngine::MrftoSetFrequencyComplete(
 TInt aError )
 {
-DEBUG_API_A1("CMMFRadioBackendEngine::MrftoSetFrequencyComplete: aError =  %d", aError);
+//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoSetFrequencyComplete: aError =  %d", aError);
 //  RDebug::Print(_L("CMMFRadioBackendEngine::MrftoFrrequencyComplete: aError = %d"), aError);
 TInt freq = 0;
 if (!aError)
 {
 iFmTunerUtility->GetFrequency(freq);
 }
-DEBUG_API_A1("CMMFRadioBackendEngine::MrftoSetFrequencyComplete: new freq is: %d", freq);
+//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoSetFrequencyComplete: new freq is: %d", freq);
-//  RDebug::Print(_L("CMMFRadioBackendEngine::MrftoSetFrequencyComplete: new freq is: %d"), freq);
+XARadioItfAdapt_SetFrequencyComplete((XAAdaptationBaseCtx*)iAdaptContext, aError, freq);
-XARadioItfAdapt_SetFrequencyComplete((XAAdaptationBaseCtx*)iRadioAdaptContext, aError, freq);
 }
 // ----------------------------------------------------
 // CMMFRadioBackendEngine::MrftoSetFrequencyRangeComplete
 //
 // ----------------------------------------------------
 //
 void CMMFRadioBackendEngine::MrftoSetFrequencyRangeComplete(
 TInt aError )
 {
-DEBUG_API_A1("CMMFRadioBackendEngine::MrftoSetFrequencyRangeComplete: aError =  %d", aError);
+//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoSetFrequencyRangeComplete: aError =  %d", aError);
-//  RDebug::Print(_L("CMMFRadioBackendEngine::MrftoSetFrequencyRangeComplete: aError = %d"), aError);
+XARadioItfAdapt_SetFrequencyRangeComplete((XAAdaptationBaseCtx*)iAdaptContext, aError);
-XARadioItfAdapt_SetFrequencyRangeComplete((XAAdaptationBaseCtx*)iRadioAdaptContext, aError);
 }
 // ----------------------------------------------------
 // CMMFRadioBackendEngine::MrftoRequestTunerControlComplete
 // ----------------------------------------------------
 //
 void CMMFRadioBackendEngine::MrftoRequestTunerControlComplete(
 TInt aError)
 {
-//  RDebug::Print(_L("CMMFRadioBackendEngine::MrftoRequestTunerControlComplete: aError = %d"), aError);
 }
 // ----------------------------------------------------
 // CMMFRadioBackendEngine::MrpoBalanceChange
 //
 // ----------------------------------------------------
 //
 void CMMFRadioBackendEngine::MrpoMuteChange(
 TBool aMute )
 {
-XANokiaVolumeExtItfAdapt_MuteChange((XAAdaptationBaseCtx*)iPlayerAdaptContext, aMute);
+XARadioItfAdapt_MuteChange((XAAdaptationBaseCtx*)iAdaptContext, aMute);
 }
 // ----------------------------------------------------
 // CMMFRadioBackendEngine::MrpoVolumeChange
 //
 // ----------------------------------------------------
 //
 void CMMFRadioBackendEngine::MrpoVolumeChange(
 TInt aVolume )
 {
-XANokiaLinearVolumeItfAdapt_VolumeChange((XAAdaptationBaseCtx*)iPlayerAdaptContext, aVolume);
+XARadioItfAdapt_VolumeChange((XAAdaptationBaseCtx*)iAdaptContext, aVolume);
 }
 // ----------------------------------------------------
 // CMMFRadioBackendEngine::MrpoStateChange This is Tuner State
 // Called when the state of the tuner changes
 //
 void CMMFRadioBackendEngine::MrpoStateChange(
 TPlayerState aState,
 TInt aError )
 {
-if ( aError )
+//    if ( aError )
-{
+//    {
-DEBUG_API_A1("CMMFRadioBackendEngine::MrpoStateChange: aError =  %d", aError);
+//       DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrpoStateChange: aError =  %d", aError);
-//     RDebug::Print(_L("CMMFRadioBackendEngine::MrpoStateChange: aError = %d"), aError);
+//    }
-}
+//    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrpoStateChange: new state =  %d", aState);
-DEBUG_API_A1("CMMFRadioBackendEngine::MrpoStateChange: new state =  %d", aState);
-//  RDebug::Print(_L("CMMFRadioBackendEngine::MrpoStateChange: new state = %d"), aState);
 if ( aState == ERadioPlayerPlaying )
 {
-XAPlayItfAdaptMMF_StateChange((XAAdaptationBaseCtx*)iPlayerAdaptContext, ETrue);
+XARadioItfAdapt_StateChange((XAAdaptationBaseCtx*)iAdaptContext, ETrue);
 }
 else  // ERadioPlayerIdle
 {
-XAPlayItfAdaptMMF_StateChange((XAAdaptationBaseCtx*)iPlayerAdaptContext, EFalse);
+XARadioItfAdapt_StateChange((XAAdaptationBaseCtx*)iAdaptContext, EFalse);
 }
 }
 extern "C" {
 void* cmmfradiobackendengine_init()
 {
 return CMMFRadioBackendEngine::Instance();
 }
-void cmmfradiobackendengine_delete(void* context)
+void cmmfradiobackendengine_delete(void* pContext)
 {
-((CMMFRadioBackendEngine*)(context))->DeleteInstance();
+((CMMFRadioBackendEngine*)(pContext))->DeleteInstance();
 }
-void  set_frequency(void* context, XAuint32 freq)
+void  set_frequency(void* pContext, void* pAdaptcontext, XAuint32 freq)
 {
-((CMMFRadioBackendEngine*)(context))->SetFrequency((TInt)freq);
+((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
-}
+((CMMFRadioBackendEngine*)(pContext))->SetFrequency((TInt)freq);
+}
-XAresult  get_frequency(void* context, XAuint32* freq)
-{
+XAresult  get_frequency(void* pContext, XAuint32* pFreq)
-return ((CMMFRadioBackendEngine*)(context))->GetFrequency((TInt&)*freq);
+{
-}
+return ((CMMFRadioBackendEngine*)(pContext))->GetFrequency((TInt&)*pFreq);
+}
-XAresult  get_signal_strength(void* context, XAuint32* signalStrength)
-{
+XAresult  get_signal_strength(void* pContext, XAuint32* pSignalStrength)
-return ((CMMFRadioBackendEngine*)(context))->GetSignalStrength((TInt&)*signalStrength);
+{
-}
+return ((CMMFRadioBackendEngine*)(pContext))->GetSignalStrength((TInt&)*pSignalStrength);
+}
-void station_seek(void* context, XAboolean upwards)
-{
+void station_seek(void* pContext, XAboolean upwards)
-((CMMFRadioBackendEngine*)(context))->StationSeek(upwards);
+{
-}
+((CMMFRadioBackendEngine*)(pContext))->StationSeek(upwards);
+}
-void cancel_set_frequency(void* context)
-{
+void cancel_set_frequency(void* pContext, void* pAdaptcontext)
-((CMMFRadioBackendEngine*)(context))->CancelSetFrequency();
+{
-}
+((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
+((CMMFRadioBackendEngine*)(pContext))->CancelSetFrequency();
-void cancel_station_seek(void* context)
+}
-{
-((CMMFRadioBackendEngine*)(context))->CancelStationSeek();
+void cancel_station_seek(void* pContext)
-}
+{
+((CMMFRadioBackendEngine*)(pContext))->CancelStationSeek();
-void set_freq_range(void* context, XAuint8 range)
+}
-{
-((CMMFRadioBackendEngine*)(context))->SetFreqRange((TFmRadioFrequencyRange)range);
+void set_freq_range(void* pContext, void* pAdaptcontext, XAuint8 range)
-}
+{
+((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
-XAresult  get_freq_range(void* context, XAuint8* range)
+((CMMFRadioBackendEngine*)(pContext))->SetFreqRange((TFmRadioFrequencyRange)range);
-{
+}
-return ((CMMFRadioBackendEngine*)(context))->GetFreqRange((TFmRadioFrequencyRange&)*range);
-}
+XAresult  get_freq_range(void* pContext, XAuint8* pRange)
+{
-XAresult  get_freq_range_properties(void* context, XAuint8 aRange, XAuint32* aMinFreq, XAuint32* aMaxFreq)
+return ((CMMFRadioBackendEngine*)(pContext))->GetFreqRange((TFmRadioFrequencyRange&)*pRange);
-{
+}
-return ((CMMFRadioBackendEngine*)(context))->GetFreqRangeProperties((TFmRadioFrequencyRange&) aRange, (TInt&) *aMinFreq, (TInt&) *aMaxFreq);
-}
+XAresult  get_freq_range_properties(void* pContext, XAuint8 aRange, XAuint32* pMinFreq, XAuint32* pMaxFreq)
+{
-XAresult  get_max_volume(void* context, XAmillibel* maxVol)
+return ((CMMFRadioBackendEngine*)(pContext))->GetFreqRangeProperties((TFmRadioFrequencyRange&) aRange, (TInt&) *pMinFreq, (TInt&) *pMaxFreq);
-{
+}
-return  ((CMMFRadioBackendEngine*)(context))->GetMaxVolume((TInt&)*maxVol);
-}
+XAresult  get_max_volume(void* pContext, XAmillibel* pMaxVol)
+{
-XAresult  set_volume(void* context, XAuint32 vol)
+return  ((CMMFRadioBackendEngine*)(pContext))->GetMaxVolume((TInt&)*pMaxVol);
-{
+}
-return ((CMMFRadioBackendEngine*)(context))->SetVolume((TInt)vol);
-}
+XAresult  set_volume(void* pContext, void* pAdaptcontext, XAuint32 vol)
+{
-XAresult  get_volume(void* context, XAuint32* vol)
+((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
-{
+return ((CMMFRadioBackendEngine*)(pContext))->SetVolume((TInt)vol);
-return ((CMMFRadioBackendEngine*)(context))->GetVolume((TInt&)*vol);
+}
-}
+XAresult  get_volume(void* pContext, XAuint32* pVol)
-XAresult  set_mute(void* context, XAboolean mute)
+{
-{
+return ((CMMFRadioBackendEngine*)(pContext))->GetVolume((TInt&)*pVol);
-return ((CMMFRadioBackendEngine*)(context))->SetMute(mute);
+}
-}
+XAresult  set_mute(void* pContext, void* pAdaptcontext, XAboolean mute)
-XAresult  get_stereo_mode(void* context, XAuint32* mode)
+{
-{
+((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
-return ((CMMFRadioBackendEngine*)(context))->GetForcedMonoReception(*mode);
+return ((CMMFRadioBackendEngine*)(pContext))->SetMute(mute);
 }
-XAresult  set_stereo_mode(void* context, XAuint32 mode)
+XAresult  get_stereo_mode(void* pContext, XAuint32* pMode)
 {
-return ((CMMFRadioBackendEngine*)(context))->ForceMonoReception(mode);
+return ((CMMFRadioBackendEngine*)(pContext))->GetForcedMonoReception((TUint&)*pMode);
 }
-void play_radio(void* context)
+XAresult  set_stereo_mode(void* pContext, void* pAdaptcontext, XAuint32 mode)
 {
-((CMMFRadioBackendEngine*)(context))->PlayRadio();
+((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
-}
+return ((CMMFRadioBackendEngine*)(pContext))->ForceMonoReception(mode);
+}
-void stop_radio(void* context)
-{
+void play_radio(void* pContext, void* pAdaptcontext)
-((CMMFRadioBackendEngine*)(context))->StopRadio();
+{
-}
+((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
+((CMMFRadioBackendEngine*)(pContext))->PlayRadio();
-XAresult mmf_set_radio_adapt_context(void * context, void * adaptcontext)
+}
-{
-return ((CMMFRadioBackendEngine*)(context))->SetRadioAdaptContext(adaptcontext);
+void stop_radio(void* pContext, void* pAdaptcontext)
-}
+{
+((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
-XAresult mmf_set_player_adapt_context(void * context, void * adaptcontext)
+((CMMFRadioBackendEngine*)(pContext))->StopRadio();
-{
+}
-return ((CMMFRadioBackendEngine*)(context))->SetPlayerAdaptContext(adaptcontext);
+void get_squelch(void* pContext, XAboolean* pSquelch)
-}
+{
-}
+((CMMFRadioBackendEngine*)(pContext))->GetSquelch((TBool&)*pSquelch);
+}
+void set_squelch(void* pContext, void* pAdaptcontext, XAboolean squelch)
+{
+((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
+((CMMFRadioBackendEngine*)(pContext))->SetSquelch((TBool)squelch);
+}
+}

changeset 52	4ce423f34688
parent 47	c2e43643db4c
child 55	e267340986c9