Mercurial Mercurial > oss > FCL > sf > mw > mmmw / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
khronosfws/openmax_al/src/mmf_adaptation/cmmfradiobackendengine.cpp
changeset 53 eabc8c503852
parent 48 a493a607b5bf
equal deleted inserted replaced
48:a493a607b5bf 53:eabc8c503852 
    58     }
 
    58     }
 
    59 }
 
    59 }
 
    60 
    60 
    61 CMMFRadioBackendEngine::~CMMFRadioBackendEngine()
 
    61 CMMFRadioBackendEngine::~CMMFRadioBackendEngine()
 
    62 {
 
    62 {
 
       
    63 
    63 }
 
    64 }
 
    64 
    65 
    65 CMMFRadioBackendEngine::CMMFRadioBackendEngine()
 
    66 CMMFRadioBackendEngine::CMMFRadioBackendEngine()
 
    66 {
 
    67 {
 
    67 
    68 
   109     {
 
   110     {
 
   110         iFmTunerUtility->SetFrequency(aFreq);
 
   111         iFmTunerUtility->SetFrequency(aFreq);
 
   111     }
 
   112     }
 
   112 }
 
   113 }
 
   113 
   114 
   114 TInt CMMFRadioBackendEngine::GetFrequency(TInt& aFreq)
 
   115 XAresult CMMFRadioBackendEngine::GetFrequency(TInt& aFreq)
 
   115 {
 
   116 {
 
   116 //    DEBUG_CPP_API("CMMFRadioBackendEngine::GetFrequency");
 
   117 //    DEBUG_CPP_API("CMMFRadioBackendEngine::GetFrequency");
 
   117     TInt ret = KErrNotFound;
 
   118     TInt ret = KErrNotFound;
 
   118     if (iFmTunerUtility)
 
   119     if (iFmTunerUtility)
 
   119     {
 
   120     {
 
   123             aFreq = iDefaultFrequency;
 
   124             aFreq = iDefaultFrequency;
 
   124             ret = KErrNone;
 
   125             ret = KErrNone;
 
   125         }
 
   126         }
 
   126     }
 
   127     }
 
   127 //  DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetFrequency RET: %d", ret);
 
   128 //  DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetFrequency RET: %d", ret);
 
   128     return ret;
 
   129     return TranslateError(ret);
 
   129 }
 
   130 }
 
   130 
   131 
   131 TInt CMMFRadioBackendEngine::GetSignalStrength(TInt& aSignalStrength)
 
   132 XAresult CMMFRadioBackendEngine::GetSignalStrength(TInt& aSignalStrength)
 
   132 {
 
   133 {
 
   133     TInt ret = KErrNotFound;
 
   134     TInt ret = KErrNotFound;
 
   134     if (iFmTunerUtility)
 
   135     if (iFmTunerUtility)
 
   135     {
 
   136     {
 
   136         ret = iFmTunerUtility->GetSignalStrength(aSignalStrength);
 
   137         ret = iFmTunerUtility->GetSignalStrength(aSignalStrength);
 
   137     }
 
   138     }
 
   138 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetSignalStrength RET: %d", ret);
 
   139 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetSignalStrength RET: %d", ret);
 
   139 //  RDebug::Print(_L("CMMFRadioBackendEngine::GetSignalStrength RET: %d"), ret);
 
   140     return TranslateError(ret);
 
   140     return ret;
 
       
   141 }
 
   141 }
 
   142 
   142 
   143 void CMMFRadioBackendEngine::CancelSetFrequency()
 
   143 void CMMFRadioBackendEngine::CancelSetFrequency()
 
   144 {
 
   144 {
 
   145     if (iFmTunerUtility)
 
   145     if (iFmTunerUtility)
 
   162     {
 
   162     {
 
   163         iFmTunerUtility->SetFrequencyRange(aRange);
 
   163         iFmTunerUtility->SetFrequencyRange(aRange);
 
   164     }
 
   164     }
 
   165 }
 
   165 }
 
   166 
   166 
   167 TInt CMMFRadioBackendEngine::GetFreqRange(TFmRadioFrequencyRange& aRange)
 
   167 XAresult CMMFRadioBackendEngine::GetFreqRange(TFmRadioFrequencyRange& aRange)
 
   168 {
 
   168 {
 
   169     TInt ret = KErrNotFound;
 
   169     TInt ret = KErrNotFound;
 
   170     TInt minFreq;
 
   170     TInt minFreq;
 
   171     TInt maxFreq;
 
   171     TInt maxFreq;
 
   172 
   172 
   179             maxFreq = iDefaultMaxFreq;
 
   179             maxFreq = iDefaultMaxFreq;
 
   180             aRange = iDefaultFreqRange;
 
   180             aRange = iDefaultFreqRange;
 
   181             ret = KErrNone;
 
   181             ret = KErrNone;
 
   182         }
 
   182         }
 
   183     }
 
   183     }
 
   184  //   DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetFreqRange RET: %d", ret);
 
   184 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetFreqRange RET: %d", ret);
 
   185     return ret;
 
   185     return TranslateError(ret);
 
   186 }
 
   186 }
 
   187 
   187 
   188 TInt CMMFRadioBackendEngine::GetFreqRangeProperties(TFmRadioFrequencyRange& aRange, TInt& aMinFreq, TInt& aMaxFreq)
 
   188 XAresult CMMFRadioBackendEngine::GetFreqRangeProperties(TFmRadioFrequencyRange& aRange, TInt& aMinFreq, TInt& aMaxFreq)
 
   189 {
 
   189 {
 
   190     TInt ret = KErrNotFound;
 
   190     TInt ret = KErrNotFound;
 
   191     if (iFmTunerUtility)
 
   191     if (iFmTunerUtility)
 
   192     {
 
   192     {
 
   193         ret = iFmTunerUtility->GetFrequencyRange((TFmRadioFrequencyRange&)aRange, (TInt&)aMinFreq, (TInt&)aMaxFreq);
 
   193         ret = iFmTunerUtility->GetFrequencyRange((TFmRadioFrequencyRange&)aRange, (TInt&)aMinFreq, (TInt&)aMaxFreq);
 
   197             aMinFreq = iDefaultMinFreq;
 
   197             aMinFreq = iDefaultMinFreq;
 
   198             aMaxFreq = iDefaultMaxFreq;
 
   198             aMaxFreq = iDefaultMaxFreq;
 
   199             ret = KErrNone;
 
   199             ret = KErrNone;
 
   200         }
 
   200         }
 
   201     }
 
   201     }
 
   202 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetFreqRangeProperties RET: %d", ret);
 
   202  //   DEBUG_CPP_API_A1("CMMFRadioBackendEngine::GetFreqRangeProperties RET: %d", ret);
 
   203     return ret;
 
   203     return TranslateError(ret);
 
   204 }
 
   204 }
 
   205 TInt CMMFRadioBackendEngine::GetMaxVolume(TInt& aMaxVol)
 
   205 
   206 {
 
   206 XAresult CMMFRadioBackendEngine::SetVolume(TInt aVol)
 
   207     TInt ret = KErrNotFound;
 
       
   208     if (iRadioPlayerUtility)
 
       
   209     {
 
       
   210         ret = iRadioPlayerUtility->GetMaxVolume(aMaxVol);
 
       
   211     }
 
       
   212     return ret;
 
       
   213 }
 
       
   214 
       
   215 TInt CMMFRadioBackendEngine::SetVolume(TInt aVol)
 
       
   216 {
 
   207 {
 
   217     TInt ret = KErrNotFound; 
   208     TInt ret = KErrNotFound; 
   218     if (iRadioPlayerUtility)
 
   209     if (iRadioPlayerUtility)
 
   219     {
 
   210     {
 
   220         ret = iRadioPlayerUtility->SetVolume(aVol);
 
   211         ret = iRadioPlayerUtility->SetVolume(aVol);
 
   221     }
 
   212     }
 
   222     return ret;
 
   213     return TranslateError(ret);
 
   223 }
 
   214 }
 
   224 
   215 
   225 TInt CMMFRadioBackendEngine::SetMute(TBool aMute)
 
   216 XAresult CMMFRadioBackendEngine::SetMute(TBool aMute)
 
   226 {
 
   217 {
 
   227     TInt ret = KErrNotFound;
 
   218     TInt ret = KErrNotFound;
 
   228     if (iRadioPlayerUtility)
 
   219     if (iRadioPlayerUtility)
 
   229     {
 
   220     {
 
   230         ret = iRadioPlayerUtility->Mute(aMute);
 
   221         ret = iRadioPlayerUtility->Mute(aMute);
 
   231     }
 
   222     }
 
   232     return ret;
 
   223     return TranslateError(ret);
 
   233 }
 
   224 }
 
   234 
   225 
   235 TInt CMMFRadioBackendEngine::GetVolume(TInt& aVol)
 
   226 XAresult CMMFRadioBackendEngine::GetVolume(TInt& aVol)
 
   236 {
 
   227 {
 
   237     TInt ret = KErrNotFound;
 
   228     TInt ret = KErrNotFound;
 
   238     if (iRadioPlayerUtility)
 
   229     if (iRadioPlayerUtility)
 
   239     {
 
   230     {
 
   240         ret = iRadioPlayerUtility->GetVolume(aVol);
 
   231         ret = iRadioPlayerUtility->GetVolume(aVol);
 
   241     }
 
   232     }
 
   242     return ret;
 
   233     return TranslateError(ret);
 
   243 }
 
   234 }
 
   244 
   235 
   245 TInt CMMFRadioBackendEngine::GetForcedMonoReception(TUint& aForcedMono)
 
   236 XAresult CMMFRadioBackendEngine::GetForcedMonoReception(TUint& aForcedMono)
 
   246 {
 
   237 {
 
   247     TInt ret = KErrNotFound;
 
   238     TInt ret = KErrNotFound;
 
   248     TBool forceMono(EFalse);
 
   239     TBool forceMono = XA_BOOLEAN_FALSE;
 
   249 
   240 
   250     if (iFmTunerUtility)
 
   241     if (iFmTunerUtility)
 
   251     {
 
   242     {
 
   252         ret = iFmTunerUtility->GetForcedMonoReception(forceMono);
 
   243         ret = iFmTunerUtility->GetForcedMonoReception(forceMono);
 
   253         if (ret == KErrNotReady)
 
   244         if (ret == KErrNotReady)
 
   254         {
 
   245         {
 
   255             aForcedMono = XA_STEREOMODE_AUTO; // Radio Utility Default value
 
   246             aForcedMono = XA_STEREOMODE_AUTO; // Radio Utility Default value
 
   256             return KErrNone;
 
   247             return TranslateError(KErrNone);
 
   257         }
 
   248         }
 
   258     }
 
   249     }
 
   259 
   250 
   260     if (forceMono)
 
   251     if (forceMono)
 
   261     {
 
   252     {
 
   266         if (iForceStereo)
 
   257         if (iForceStereo)
 
   267             aForcedMono = XA_STEREOMODE_STEREO;
 
   258             aForcedMono = XA_STEREOMODE_STEREO;
 
   268         else
 
   259         else
 
   269             aForcedMono = XA_STEREOMODE_AUTO;
 
   260             aForcedMono = XA_STEREOMODE_AUTO;
 
   270     }
 
   261     }
 
   271     return ret;
 
   262     return TranslateError(ret);
 
   272 }
 
   263 }
 
   273 
   264 
   274 void CMMFRadioBackendEngine::PlayRadio()
 
   265 void CMMFRadioBackendEngine::PlayRadio()
 
   275 {
 
   266 {
 
   276     if (iRadioPlayerUtility)
 
   267     if (iRadioPlayerUtility)
 
   285     {
 
   276     {
 
   286         iRadioPlayerUtility->Stop();
 
   277         iRadioPlayerUtility->Stop();
 
   287     }
 
   278     }
 
   288 }
 
   279 }
 
   289 
   280 
   290 TInt CMMFRadioBackendEngine::ForceMonoReception(TUint aForcedMono)
 
   281 XAresult CMMFRadioBackendEngine::ForceMonoReception(TUint aForcedMono)
 
   291 {
 
   282 {
 
   292     TInt ret = KErrNotFound;
 
   283     TInt ret = KErrNotFound;
 
   293     TUint currentMode;
 
   284     TUint currentMode;
 
   294 
   285 
   295     ret = GetForcedMonoReception(currentMode);
 
   286     ret = GetForcedMonoReception(currentMode);
 
   296     if (ret != XA_RESULT_SUCCESS)
 
   287     if (ret != XA_RESULT_SUCCESS)
 
   297         return ret;
 
   288         return TranslateError(ret);
 
   298 
   289 
   299     if (iFmTunerUtility)
 
   290     if (iFmTunerUtility)
 
   300     {
 
   291     {
 
   301         if (aForcedMono == XA_STEREOMODE_MONO)
 
   292         if (aForcedMono == XA_STEREOMODE_MONO)
 
   302         {
 
   293         {
 
   326             {
 
   317             {
 
   327                 ret = iFmTunerUtility->ForceMonoReception(EFalse);
 
   318                 ret = iFmTunerUtility->ForceMonoReception(EFalse);
 
   328             }
 
   319             }
 
   329         }
 
   320         }
 
   330     }
 
   321     }
 
   331  //   DEBUG_CPP_API_A1("CMMFRadioBackendEngine::ForceMonoReception RET: %d", ret);
 
   322 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::ForceMonoReception RET: %d", ret);
 
   332     return ret;
 
   323     return TranslateError(ret);
 
   333 }
 
   324 }
 
   334 
   325 
   335 XAresult CMMFRadioBackendEngine::SetForceMonoFlag() 
   326 XAresult CMMFRadioBackendEngine::SetForceMonoFlag() 
   336 {
 
   327 {
 
   337     TInt ret = KErrNotFound;
 
   328     TInt ret = KErrNotFound;
 
   338     TBool forceMono;
 
   329     TBool forceMono = XA_BOOLEAN_FALSE;
 
   339 
   330 
   340     if (iFmTunerUtility)
 
   331     if (iFmTunerUtility)
 
   341     {
 
   332     {
 
   342         ret = iFmTunerUtility->GetForcedMonoReception(forceMono);
 
   333         ret = iFmTunerUtility->GetForcedMonoReception(forceMono);
 
   343         if (ret == KErrNotReady)
 
   334         if (ret == KErrNotReady)
 
   344         {
 
   335         {
 
   345             // For Radio Utility Default value = XA_STEREOMODE_STEREO
 
   336             // For Radio Utility Default value = XA_STEREOMODE_STEREO
 
   346             iForceStereo = ETrue;
 
   337             iForceStereo = ETrue;
 
   347             return KErrNone;
 
   338             return TranslateError(KErrNone);
 
   348         }
 
   339         }
 
   349     }
 
   340     }
 
   350     if (forceMono == XA_STEREOMODE_MONO)
 
   341     if (!forceMono)
 
   351     {
 
   342     {
 
   352         iForceStereo = EFalse;
 
   343         iForceStereo = EFalse;
 
   353     }
 
   344     }
 
   354     else
 
   345     else
 
   355     {
 
   346     {
 
   356         iForceStereo = ETrue;
 
   347         iForceStereo = ETrue;
 
   357     }
 
   348     }
 
   358   return ret;
 
   349   return TranslateError(ret);
 
   359 }
 
   350 }
 
   360 
   351 
   361 TInt CMMFRadioBackendEngine::GetSquelch(TBool& aSquelch)
 
   352 XAresult CMMFRadioBackendEngine::GetSquelch(TBool& aSquelch)
 
   362 {
 
   353 {
 
   363     TInt ret = KErrNotFound;
 
   354     TInt ret = KErrNotFound;
 
   364     if (iFmTunerUtility)
 
   355     if (iFmTunerUtility)
 
   365     {
 
   356     {
 
   366         ret = iFmTunerUtility->GetSquelch(aSquelch);
 
   357         ret = iFmTunerUtility->GetSquelch(aSquelch);
 
   367     }
 
   358     }
 
   368     return ret;
 
   359     return TranslateError(ret);
 
   369 }
 
   360 }
 
   370 
   361 
   371 TInt CMMFRadioBackendEngine::SetSquelch(TBool aSquelch)
 
   362 XAresult CMMFRadioBackendEngine::SetSquelch(TBool aSquelch)
 
   372 {
 
   363 {
 
   373     TInt ret = KErrNotFound;
 
   364     TInt ret = KErrNotFound;
 
   374     if (iFmTunerUtility)
 
   365     if (iFmTunerUtility)
 
   375     {
 
   366     {
 
   376         ret = iFmTunerUtility->SetSquelch(aSquelch);
 
   367         ret = iFmTunerUtility->SetSquelch(aSquelch);
 
   377     }
 
   368     }
 
   378     return ret;
 
   369     return TranslateError(ret);
 
   379 }
 
   370 }
 
   380 
   371 
   381 void CMMFRadioBackendEngine::SetAdaptContext(void * adaptcontext)
 
   372 void CMMFRadioBackendEngine::SetAdaptContext(void * adaptcontext)
 
   382 {
 
   373 {
 
   383     iAdaptContext = (XAAdaptationBaseCtx*)adaptcontext;
 
   374     iAdaptContext = (XAAdaptationBaseCtx*)adaptcontext;
 
   384 }
 
   375 }
 
   385 
   376 
   386 XAresult TranslateError(TInt error)
 
   377 XAresult CMMFRadioBackendEngine::TranslateError(TInt error)
 
   387     {
 
   378     {
 
   388     XAresult status(XA_RESULT_SUCCESS);
 
   379     XAresult status(XA_RESULT_SUCCESS);
 
   389     switch(error)
 
   380     switch(error)
 
   390         {
 
   381         {
 
   391         case KErrNone:
 
   382         case KErrNone:
 
   392             status = XA_RESULT_SUCCESS;
 
   383             status = XA_RESULT_SUCCESS;
 
       
   384             break;
 
       
   385         case KErrNotFound:
 
       
   386             status = XA_RESULT_MEMORY_FAILURE;
 
   393             break;
 
   387             break;
 
   394         // to do: investigate and add other possible errors:
 
   388         // to do: investigate and add other possible errors:
 
   395             
   389             
   396        /* case XA_RESULT_PRECONDITIONS_VIOLATED:
 
   390        /* case XA_RESULT_PRECONDITIONS_VIOLATED:
 
   397  
   391  
   398             break;
 
   392             break;
 
   399         case XA_RESULT_PARAMETER_INVALID:
 
   393         case XA_RESULT_PARAMETER_INVALID:
 
   400 
   394 
   401             break;
 
   395             break;
 
   402         case XA_RESULT_MEMORY_FAILURE:
 
   396 
   403 
       
   404             break;
 
       
   405         case XA_RESULT_RESOURCE_ERROR:
 
   397         case XA_RESULT_RESOURCE_ERROR:
 
   406 
   398 
   407             break;
 
   399             break;
 
   408         case XA_RESULT_RESOURCE_LOST:
 
   400         case XA_RESULT_RESOURCE_LOST:
 
   409  
   401  
   430 
   422 
   431             break;
 
   423             break;
 
   432         case XA_RESULT_INTERNAL_ERROR:
 
   424         case XA_RESULT_INTERNAL_ERROR:
 
   433 
   425 
   434             break;
 
   426             break;
 
   435         case XA_RESULT_UNKNOWN_ERROR:
 
   427 
   436 
       
   437             break;
 
       
   438         case XA_RESULT_OPERATION_ABORTED:
 
   428         case XA_RESULT_OPERATION_ABORTED:
 
   439 
   429 
   440             break;
 
   430             break;
 
   441         case XA_RESULT_CONTROL_LOST:
 
   431         case XA_RESULT_CONTROL_LOST:
 
   442 
   432 
   443             break;
 
   433             break;
 
   444             */
 
   434             */
 
   445         default:
 
   435         default:
 
   446         	break;
 
   436             status = XA_RESULT_UNKNOWN_ERROR;
 
       
   437             break;
 
   447         } // end switch
 
   438         } // end switch
 
   448     return status;
 
   439     return status;
 
   449     }
 
   440     }
 
   450 // -----------------------------------------------------------------------------
 
   441 // -----------------------------------------------------------------------------
 
   451 // CMMFRadioBackendEngine::MrpeoPresetChanged
 
   442 // CMMFRadioBackendEngine::MrpeoPresetChanged
 
   500 // ----------------------------------------------------
 
   491 // ----------------------------------------------------
 
   501 //
 
   492 //
 
   502 void CMMFRadioBackendEngine::MrftoFrequencyRangeChange(
 
   493 void CMMFRadioBackendEngine::MrftoFrequencyRangeChange(
 
   503     TFmRadioFrequencyRange aNewRange )
 
   494     TFmRadioFrequencyRange aNewRange )
 
   504 {
 
   495 {
 
   505  //   DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoFrequencyRangeChange: aNewRange =  %d", aNewRange);
 
   496 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoFrequencyRangeChange: aNewRange =  %d", aNewRange);
 
   506     XARadioItfAdapt_FrequencyRangeChange((XAAdaptationBaseCtx*)iAdaptContext, aNewRange);
 
   497     XARadioItfAdapt_FrequencyRangeChange((XAAdaptationBaseCtx*)iAdaptContext, aNewRange);
 
   507 }
 
   498 }
 
   508 
   499 
   509 // ----------------------------------------------------
 
   500 // ----------------------------------------------------
 
   510 // CMMFRadioBackendEngine::MrftoOfflineModeStatusChange
 
   501 // CMMFRadioBackendEngine::MrftoOfflineModeStatusChange
 
   557 //
 
   548 //
 
   558 void CMMFRadioBackendEngine::MrftoSetFrequencyComplete(
 
   549 void CMMFRadioBackendEngine::MrftoSetFrequencyComplete(
 
   559     TInt aError )
 
   550     TInt aError )
 
   560 {
 
   551 {
 
   561 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoSetFrequencyComplete: aError =  %d", aError);
 
   552 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoSetFrequencyComplete: aError =  %d", aError);
 
   562 //  RDebug::Print(_L("CMMFRadioBackendEngine::MrftoFrrequencyComplete: aError = %d"), aError);
 
       
   563     TInt freq = 0;
 
   553     TInt freq = 0;
 
   564     if (!aError)
 
   554     if (aError == KErrNone)
 
   565     {
 
   555     {
 
   566         iFmTunerUtility->GetFrequency(freq);
 
   556         iFmTunerUtility->GetFrequency(freq);
 
   567     }
 
   557     }
 
   568 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoSetFrequencyComplete: new freq is: %d", freq);
 
   558 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrftoSetFrequencyComplete: new freq is: %d", freq);
 
   569     XARadioItfAdapt_SetFrequencyComplete((XAAdaptationBaseCtx*)iAdaptContext, aError, freq);
 
   559     XARadioItfAdapt_SetFrequencyComplete((XAAdaptationBaseCtx*)iAdaptContext, aError, freq);
 
   634     TPlayerState aState,
 
   624     TPlayerState aState,
 
   635     TInt aError )
 
   625     TInt aError )
 
   636 {
 
   626 {
 
   637 //    if ( aError )
 
   627 //    if ( aError )
 
   638 //    {
 
   628 //    {
 
   639  //       DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrpoStateChange: aError =  %d", aError);
 
   629 //        DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrpoStateChange: aError =  %d", aError);
 
   640 //    }
 
   630 //    }
 
   641 
   631 
   642 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrpoStateChange: new state =  %d", aState);
 
   632 //    DEBUG_CPP_API_A1("CMMFRadioBackendEngine::MrpoStateChange: new state =  %d", aState);
 
   643 
   633 
   644     if ( aState == ERadioPlayerPlaying )
 
   634     if ( aState == ERadioPlayerPlaying )
 
   660     }
 
   650     }
 
   661 
   651 
   662     void cmmfradiobackendengine_delete(void* pContext)
 
   652     void cmmfradiobackendengine_delete(void* pContext)
 
   663     { 
   653     { 
   664         ((CMMFRadioBackendEngine*)(pContext))->DeleteInstance();
 
   654         ((CMMFRadioBackendEngine*)(pContext))->DeleteInstance();
 
       
   655         delete ((CMMFRadioBackendEngine*)pContext);
 
   665     }
 
   656     }
 
   666 
   657 
   667     void  set_frequency(void* pContext, void* pAdaptcontext, XAuint32 freq)
 
   658     void  set_frequency(void* pContext, void* pAdaptcontext, XAuint32 freq)
 
   668     {
 
   659     {
 
   669         ((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
 
   660         ((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
 
   710     XAresult  get_freq_range_properties(void* pContext, XAuint8 aRange, XAuint32* pMinFreq, XAuint32* pMaxFreq)
 
   701     XAresult  get_freq_range_properties(void* pContext, XAuint8 aRange, XAuint32* pMinFreq, XAuint32* pMaxFreq)
 
   711     {
 
   702     {
 
   712         return ((CMMFRadioBackendEngine*)(pContext))->GetFreqRangeProperties((TFmRadioFrequencyRange&) aRange, (TInt&) *pMinFreq, (TInt&) *pMaxFreq);
 
   703         return ((CMMFRadioBackendEngine*)(pContext))->GetFreqRangeProperties((TFmRadioFrequencyRange&) aRange, (TInt&) *pMinFreq, (TInt&) *pMaxFreq);
 
   713     }
 
   704     }
 
   714 
   705 
   715     XAresult  get_max_volume(void* pContext, XAmillibel* pMaxVol)
 
       
   716     {
 
       
   717         return  ((CMMFRadioBackendEngine*)(pContext))->GetMaxVolume((TInt&)*pMaxVol);
 
       
   718     }
 
       
   719 
       
   720     XAresult  set_volume(void* pContext, void* pAdaptcontext, XAuint32 vol)
 
   706     XAresult  set_volume(void* pContext, void* pAdaptcontext, XAuint32 vol)
 
   721     {
 
   707     {
 
   722         ((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
 
   708         ((CMMFRadioBackendEngine*)(pContext))->SetAdaptContext(pAdaptcontext);
 
   723         return ((CMMFRadioBackendEngine*)(pContext))->SetVolume((TInt)vol);
 
   709         return ((CMMFRadioBackendEngine*)(pContext))->SetVolume((TInt)vol);
 
   724     }
 
   710     }
FCL/sf/mw/mmmw