From a8071b6a9738ef1cf48eab27ec5ce2dcd7e92180 Mon Sep 17 00:00:00 2001 From: Dominik Rekawek Date: Sun, 21 Dec 2014 13:52:05 +0100 Subject: [PATCH] [FMRadio][Feature]Getters,Interrupt,Antenna,Seek [Validation] Getters: All working and tested JS: seekUp - tested with documentation code, works seekDown -tested with documentation code, works [FMRadio][Feature]Mute,Interrupted,Antenna [Feature] JS and Cpp mute implementation. [Verification] Verified basing on tizen.fmradio.mute and console logs. [Feature] FMRadio Interrupted Listener [Validated] Validated manualy by hardcoding callbacks [Feature] Antenna listener [Verification] function antennaCallback(isAntennaConnected) { console.log("Antenna status has been changed. It is now " + (isAntennaConnected ? "connected" : "disconnected")); } tizen.fmradio.setAntennaChangeListener(antennaCallback); Change-Id: Ie14bfad76b2b9ab52bed209212c159ae2ef1e405 Signed-off-by: Dominik Rekawek --- src/radio/radio.gyp | 1 + src/radio/radio_api.js | 173 ++++++++++++---- src/radio/radio_instance.cc | 65 ++++-- src/radio/radio_instance.h | 4 +- src/radio/radio_manager.cc | 396 +++++++++++++++++++++++++++++++----- src/radio/radio_manager.h | 27 ++- 6 files changed, 544 insertions(+), 122 deletions(-) diff --git a/src/radio/radio.gyp b/src/radio/radio.gyp index be730a7c..a0d18785 100644 --- a/src/radio/radio.gyp +++ b/src/radio/radio.gyp @@ -24,6 +24,7 @@ 'packages': [ 'vconf', 'capi-media-radio', + 'capi-system-runtime-info', ] }, }], diff --git a/src/radio/radio_api.js b/src/radio/radio_api.js index e2b5ab9f..c33f9255 100644 --- a/src/radio/radio_api.js +++ b/src/radio/radio_api.js @@ -16,6 +16,74 @@ var RadioState = { READY : 'READY' }; +function FMRadioInterruptCallbackManager() { + + this.oninterrupted; + this.oninterruptfinished; +}; + +FMRadioInterruptCallbackManager.prototype.FMRadioInterruptedCBSwitch = function(args) { + if (args.action == 'oninterrupted') + this.oninterrupted(args.reason); + else + this.oninterruptfinished(); +}; + +FMRadioInterruptCallbackManager.prototype.FMRadioInterruptedSet = function(oi, oif) { + this.oninterrupted = oi; + this.oninterruptfinished = oif; + native_.addListener('FMRadio_Interrupted', this.FMRadioInterruptedCBSwitch + .bind(this)); +}; + +FMRadioInterruptCallbackManager.prototype.FMRadioInterruptedUnset = function() { + native_.removeListener('FMRadio_Interrupted'); +}; + +function FMRadioScanCallbackManager() { + + this.radioScanCallback; + +}; + +FMRadioScanCallbackManager.prototype.FMRadioScanCBSwitch = function(args) { + this.radioScanCallback(args.frequency); +}; + +FMRadioScanCallbackManager.prototype.FMRadioScanSet = function(cb) { + this.radioScanCallback = cb; + native_.addListener('FMRadio_Onfrequencyfound', + this.FMRadioScanCBSwitch.bind(this)); +}; + +FMRadioScanCallbackManager.prototype.FMRadioScanUnset = function() { + native_.removeListener('FMRadio_Onfrequencyfound'); +}; + +function FMRadioAntennaChangeCallbackManager() { + + this.onchange; + +}; + +FMRadioAntennaChangeCallbackManager.prototype.FMRadioAntennaCBSwitch = function(args) { + this.onchange(args.connected); +}; + +FMRadioAntennaChangeCallbackManager.prototype.FMRadioAntennaChangeSet = function(cb) { + this.onchange = cb; + native_.addListener('FMRadio_Antenna', this.FMRadioAntennaCBSwitch + .bind(this)); +}; + +FMRadioAntennaChangeCallbackManager.prototype.FMRadioAntennaUnset = function() { + native_.removeListener('FMRadio_Antenna'); +}; + +var antennaCBmanager = new FMRadioAntennaChangeCallbackManager(); +var interruptedCBmanager = new FMRadioInterruptCallbackManager(); +var scanCBmanager = new FMRadioScanCallbackManager(); + function FMRadioManager() { Object.defineProperties(this, { 'frequency' : { @@ -55,30 +123,48 @@ function FMRadioManager() { } }, 'mute' : { - value : 'TEST', - writable : false, - enumerable : true + enumerable : true, + get : muteGetter, + set : muteSetter } }); + function muteGetter() { + var ret = native_.callSync('FMRadio_MuteGetter'); + return native_.getResultObject(ret); + } + + function muteSetter() { + + var args = validator_.validateArgs(arguments, [ { + name : 'mute', + type : types_.BOOLEAN + } ]); + var ret = native_.callSync('FMRadio_MuteSetter', args); + } + function radioStateGetter() { var ret = native_.callSync('FMRadio_RadioStateGetter'); + return native_.getResultObject(ret); } function isAntennaConnectedGetter() { var ret = native_.callSync('FMRadio_IsAntennaConnectedGetter'); + return native_.getResultObject(ret); } function signalStrengthGetter() { var ret = native_.callSync('FMRadio_SignalStrengthGetter'); + return native_.getResultObject(ret); } function frequencyGetter() { var ret = native_.callSync('FMRadio_FrequencyGetter'); + return native_.getResultObject(ret); } @@ -127,7 +213,7 @@ FMRadioManager.prototype.start = function() { if (args.frequency) { if (args.frequency < this.frequencyLowerBound || args.frequency > this.frequencyUpperBound) - throw new tizen.WebAPIException(0, + throw new tizen.WebAPIException( tizen.WebAPIException.INVALID_VALUES_ERR, 'Frequency out of bounds'); } @@ -165,7 +251,29 @@ FMRadioManager.prototype.seekDown = function() { }; FMRadioManager.prototype.scanStart = function() { + var args = validator_.validateArgs(arguments, [ { + name : 'radioScanCallback', + type : types_.LISTENER, + values : [ 'onfrequencyfound', 'onfinished' ] + }, { + name : 'errorCallback', + type : types_.FUNCTION, + optional : true, + nullable : true + } ]); + + scanCBmanager.FMRadioScanSet(args.radioScanCallback.onfrequencyfound); + + var ret = native_.call('FMRadio_ScanStart', {}, function(result) { + if (native_.isFailure(result)) { + if (args.errorCallback) + args.errorCallback(native_.getErrorObject(result)); + } else { + scanCBmanager.FMRadioScanUnset(); + args.radioScanCallback.onfinished(result.frequencies); + } + }); }; FMRadioManager.prototype.stop = function() { @@ -173,46 +281,39 @@ FMRadioManager.prototype.stop = function() { }; FMRadioManager.prototype.scanStop = function() { + var args = validator_.validateArgs(arguments, [ { + name : 'successCallback', + type : types_.FUNCTION, + optional : true, + nullable : true + }, { + name : 'errorCallback', + type : types_.FUNCTION, + optional : true, + nullable : true + } ]); -}; - -function FMRadioInterruptManager() { - - this.oninterrupted; - this.oninterruptfinished; -}; + var ret = native_.call('FMRadio_ScanStop', {}, function(result) { + if (native_.isFailure(result)) { + if (args.errorCallback) + args.errorCallback(native_.getErrorObject(result)); + } else { -FMRadioInterruptManager.prototype.FMRadioInterruptedCBSwitch = function(args) { - if (args.action == 'oninterrupted') { - if (this.oninterrupted) { - this.oninterrupted(); - } - } else { + args.successCallback(); - if (this.oninterruptfinished) { - this.oninterruptfinished(); } - } -}; - -FMRadioInterruptManager.prototype.FMRadioInterruptedSet = function(oi, oif) { - this.oninterrupted = oi; - this.oninterruptfinished = oif; - native_.addListener('FMRadio_Interrupted', this.FMRadioInterruptedCBSwitch - .bind(this)); + }); }; -var intmgr = new FMRadioInterruptManager(); - FMRadioManager.prototype.setFMRadioInterruptedListener = function() { var args = validator_.validateArgs(arguments, [ { - name : 'eventCallback', + name : 'interruptCallback', type : types_.LISTENER, values : [ 'oninterrupted', 'oninterruptfinished' ] } ]); - intmgr.FMRadioInterruptedSet(args.eventCallback.oninterrupted, - args.eventCallback.oninterruptfinished) + interruptedCBmanager.FMRadioInterruptedSet(args.interruptCallback.oninterrupted, + args.interruptCallback.oninterruptfinished) var ret = native_.callSync('FMRadio_SetFMRadioInterruptedListener'); @@ -220,25 +321,25 @@ FMRadioManager.prototype.setFMRadioInterruptedListener = function() { FMRadioManager.prototype.unsetFMRadioInterruptedListener = function() { - // TODO intmgr unset + interruptedCBmanager.FMRadioInterruptedUnset(); var ret = native_.callSync('FMRadio_UnsetFMRadioInterruptedListener'); }; FMRadioManager.prototype.setAntennaChangeListener = function() { var args = validator_.validateArgs(arguments, [ { - name : 'eventCallback', + name : 'changeCallback', type : types_.LISTENER, values : [ 'onchange' ] } ]); - // TODO listener manager + antennaCBmanager.FMRadioAntennaChangeSet(args.changeCallback); var ret = native_.callSync('FMRadio_SetAntennaChangeListener'); }; FMRadioManager.prototype.unsetAntennaChangeListener = function() { - // TODO listener manager + antennaCBmanager.FMRadioAntennaUnset(); var ret = native_.callSync('FMRadio_UnsetAntennaChangeListener'); }; diff --git a/src/radio/radio_instance.cc b/src/radio/radio_instance.cc index cc32de43..d02b6011 100644 --- a/src/radio/radio_instance.cc +++ b/src/radio/radio_instance.cc @@ -30,8 +30,10 @@ namespace radio { REGISTER_SYNC("FMRadio_UnsetAntennaChangeListener", UnsetAntennaChangeListener); REGISTER_SYNC("FMRadio_FrequencyGetter", FrequencyGetter); REGISTER_SYNC("FMRadio_SignalStrengthGetter", SignalStrengthGetter); - REGISTER_SYNC("FMRadio_IsAntennaConnectedGetter", AntenaGetter); + REGISTER_SYNC("FMRadio_IsAntennaConnectedGetter", AntennaGetter); REGISTER_SYNC("FMRadio_RadioStateGetter", StateGetter); + REGISTER_SYNC("FMRadio_MuteSetter", MuteSetter); + REGISTER_SYNC("FMRadio_MuteGetter", MuteGetter); #undef REGISTER_SYNC #define REGISTER_ASYNC(c,x) \ RegisterHandler(c, std::bind(&RadioInstance::x, this, _1, _2)); @@ -52,29 +54,50 @@ namespace radio { return instance; } - void RadioInstance::AntenaGetter(const picojson::value& args, - picojson::object& out){ - } + void RadioInstance::MuteGetter(const picojson::value& args, + picojson::object& out) + { + bool mute = FMRadioManager::GetInstance(0)->MuteGetter(); + ReportSuccess(picojson::value(mute),out); + } + + void RadioInstance::MuteSetter(const picojson::value& args, + picojson::object& out) + { + FMRadioManager::GetInstance(0)->MuteSetter(args); + } + + void RadioInstance::AntennaGetter(const picojson::value& args, + picojson::object& out) + { + LoggerD(".cc AntennaGetter()"); + bool Antenna = FMRadioManager::GetInstance(0)->AntennaGetter(); + ReportSuccess(picojson::value(Antenna),out); + } - void RadioInstance::StateGetter(const picojson::value& args, - picojson::object& out){ - } + void RadioInstance::StateGetter(const picojson::value& args, + picojson::object& out) + { + LoggerD(".cc StateGetter()"); + std::string state = FMRadioManager::GetInstance(0)->StateGetter(); + ReportSuccess(picojson::value(state),out); + } void RadioInstance::FrequencyGetter(const picojson::value& args, picojson::object& out) { LoggerD(".cc FrequencyGetter()"); - double freq = FMRadioManager::GetInstance()->FrequencyGetter(); + double freq = FMRadioManager::GetInstance(0)->FrequencyGetter(); ReportSuccess(picojson::value(freq),out); } void RadioInstance::SignalStrengthGetter(const picojson::value& args, picojson::object& out) - { - LoggerD(".cc SignalStrengthGetter()"); - double strength = FMRadioManager::GetInstance()->SignalStrengthGetter(); - ReportSuccess(picojson::value(strength),out); - } + { + LoggerD(".cc SignalStrengthGetter()"); + double strength = FMRadioManager::GetInstance(0)->SignalStrengthGetter(); + ReportSuccess(picojson::value(strength),out); + } void RadioInstance::InstanceReportSuccess(picojson::object& out) { LoggerD(".cc InstanceReportSuccess()"); @@ -83,13 +106,13 @@ namespace radio { void RadioInstance::SeekUp(const picojson::value& args, picojson::object& out) { LoggerD(".cc SeekUp()"); - FMRadioManager::GetInstance()->SeekUp(args); + FMRadioManager::GetInstance(0)->SeekUp(args); } void RadioInstance::SeekDown(const picojson::value& args, picojson::object& out) { LoggerD(".cc SeekDown()"); - FMRadioManager::GetInstance()->SeekDown(args); + FMRadioManager::GetInstance(0)->SeekDown(args); } void RadioInstance::Start(const picojson::value& args, @@ -116,36 +139,36 @@ namespace radio { void RadioInstance::ScanStart(const picojson::value& args, picojson::object& out) { - FMRadioManager::GetInstance()->ScanStart(args); + FMRadioManager::GetInstance(0)->ScanStart(args); } void RadioInstance::ScanStop(const picojson::value& args, picojson::object& out) { - FMRadioManager::GetInstance()->ScanStop(args); + FMRadioManager::GetInstance(0)->ScanStop(args); } void RadioInstance::SetFMRadioInterruptedListener(const picojson::value& args, picojson::object& out) { LoggerD(".cc SetFMRadioInterruptedListener()"); - FMRadioManager::GetInstance()->SetFMRadioInterruptedListener(); + FMRadioManager::GetInstance(0)->SetFMRadioInterruptedListener(); } void RadioInstance::UnsetFMRadioInterruptedListener(const picojson::value& args, picojson::object& out) { LoggerD(".cc UnsetFMRadioInterruptedListener()"); - FMRadioManager::GetInstance()->UnsetFMRadioInterruptedListener(); + FMRadioManager::GetInstance(0)->UnsetFMRadioInterruptedListener(); } void RadioInstance::SetAntennaChangeListener(const picojson::value& args, picojson::object& out) { LoggerD(".cc SetAntennaChangeListener()"); - FMRadioManager::GetInstance()->SetAntennaChangeListener(); + FMRadioManager::GetInstance(0)->SetAntennaChangeListener(); } void RadioInstance::UnsetAntennaChangeListener(const picojson::value& args, picojson::object& out) { LoggerD(".cc UnsetAntennaChangeListener()"); - FMRadioManager::GetInstance()->UnsetAntennaChangeListener(); + FMRadioManager::GetInstance(0)->UnsetAntennaChangeListener(); } } diff --git a/src/radio/radio_instance.h b/src/radio/radio_instance.h index 84559934..fef4d201 100644 --- a/src/radio/radio_instance.h +++ b/src/radio/radio_instance.h @@ -24,9 +24,11 @@ class RadioInstance void InstanceReportSuccess(picojson::object& out); private: + void MuteGetter(const picojson::value& args,picojson::object& out); + void MuteSetter(const picojson::value& args,picojson::object& out); void FrequencyGetter(const picojson::value& args,picojson::object& out); void SignalStrengthGetter(const picojson::value& args,picojson::object& out); - void AntenaGetter(const picojson::value& args,picojson::object& out); + void AntennaGetter(const picojson::value& args,picojson::object& out); void StateGetter(const picojson::value& args,picojson::object& out); void SeekUp(const picojson::value& args, picojson::object& out); void SeekDown(const picojson::value& args, picojson::object& out); diff --git a/src/radio/radio_manager.cc b/src/radio/radio_manager.cc index 8327c0e2..c7de995a 100755 --- a/src/radio/radio_manager.cc +++ b/src/radio/radio_manager.cc @@ -5,12 +5,10 @@ #include "radio_manager.h" #include - #include #include - #include - +#include #include #include "common/logger.h" @@ -23,19 +21,14 @@ using namespace std; namespace extension { namespace radio { +char* state_array[] = { "READY", "PLAYING", "SCANNING" ,""}; static const double FREQ_LOWER = 87.5; -typedef struct RadioSeekCBstruct_ -{ - double cbid; - radio_h radio_instance; -} RadioSeekCBstruct; - - static void createEventSuccess(picojson::object& obj,double callbackId) { obj.insert(std::make_pair("callbackId", callbackId)); obj.insert(std::make_pair("status", picojson::value("success"))); + picojson::value event = picojson::value(obj); RadioInstance::getInstance().PostMessage(event.serialize().c_str()); } @@ -44,6 +37,7 @@ static void createEventSuccess(double callbackId) { picojson::value event = picojson::value(picojson::object()); picojson::object& obj = event.get(); + createEventSuccess(obj,callbackId); } @@ -63,7 +57,7 @@ static void createEventFail(double callbackId,const PlatformException& ex) int FMRadioManager::Create() { - if (radio_instance==NULL) + if (radio_instance == NULL) { int err = radio_create(&radio_instance); if(err){ @@ -71,11 +65,60 @@ int FMRadioManager::Create() radio_instance=NULL; } return err; - } return 0; } +bool FMRadioManager::MuteGetter() +{ + bool muted = false; + int err = radio_is_muted (radio_instance, &muted); + if (RADIO_ERROR_NONE != err) { + LoggerE("radio_is_muted %d",err); + } + return muted; +} + +void FMRadioManager::MuteSetter(const picojson::value& args) +{ + bool mute = args.get("mute").get(); + + int err = radio_set_mute (radio_instance, mute); + if (err) + { + LoggerE("radio_set_mute %d",err); + } +} + +bool FMRadioManager::AntennaGetter() +{ + bool connected = false; + int err = runtime_info_get_value_bool (RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED , &connected); + + if (err) + { + return false; + } + return connected; +} + + + +char* FMRadioManager::StateGetter() +{ + LoggerD("FMRadioManager::FrequencyGetter()"); + + radio_state_e state; + + int err = radio_get_state (radio_instance, &state); + if (err) + { + return state_array[3]; // returns "" + } + + return state_array[static_cast(state)]; +} + double FMRadioManager::FrequencyGetter() { int freq; @@ -89,6 +132,7 @@ double FMRadioManager::FrequencyGetter() } return static_cast(freq/1000); } + double FMRadioManager::SignalStrengthGetter() { int stren; @@ -100,6 +144,7 @@ double FMRadioManager::SignalStrengthGetter() LoggerE("radio_get_signal_strength()"); return 0; } + return static_cast(stren); } @@ -116,35 +161,43 @@ FMRadioManager::~FMRadioManager() LoggerD("radio_destroy() error %d",err); } -FMRadioManager* FMRadioManager::GetInstance() +FMRadioManager* FMRadioManager::GetInstance(bool safe) { static FMRadioManager instance; - instance.Create(); + int err=instance.Create(); + if(safe) + { + CheckErr("radio_create",err); + } + LoggerD("FMRadioManager::GetInstance()"); + return &instance; } void FMRadioManager::CheckErr(string str,int err) { - if(err) + + LoggerE("%s() error %d",str.c_str(),err); + + if(RADIO_ERROR_NONE == err) { - LoggerE("%s() error %d",str.c_str(),err); + return; } - - if (err==RADIO_ERROR_INVALID_PARAMETER ) + else if (RADIO_ERROR_INVALID_PARAMETER == err) { throw common::InvalidValuesException(str); } - else if(err==RADIO_ERROR_INVALID_STATE) + else if(RADIO_ERROR_INVALID_STATE == err) { - throw common::InvalidValuesException(str); + throw common::InvalidStateException(str); } - else if(err==RADIO_ERROR_SOUND_POLICY) + else if(RADIO_ERROR_SOUND_POLICY == err) { throw common::UnknownException(str); } - else if(err==RADIO_ERROR_NOT_SUPPORTED) + else if(RADIO_ERROR_NOT_SUPPORTED == err) { throw common::ServiceNotAvailableException(str); } @@ -159,7 +212,7 @@ void FMRadioManager::Start(double freq) { LoggerD("FMRadioManager::Start(%f)",freq); - int err = radio_set_frequency (radio_instance, freq); + int err = radio_set_frequency (radio_instance, freq*1000); CheckErr("radio_set_frequency",err); err= radio_start(radio_instance); @@ -174,79 +227,310 @@ void FMRadioManager::Stop() PlatformException FMRadioManager::GetException(char * name,int err) { - const int SIZE = 200; - char buff[SIZE]; - snprintf(buff,SIZE-1,"%s:%d",name,err); - //TODO Split exception types - return UnknownException(buff); + string buff=string(name); + buff+=" : "; + buff+=to_string(err); + if(RADIO_ERROR_INVALID_PARAMETER == err) + { + return InvalidValuesException(buff); + } + else if(RADIO_ERROR_INVALID_OPERATION == err) + { + return UnknownException(buff); + } + else if(RADIO_ERROR_INVALID_STATE == err) + { + return InvalidStateException(buff); + } + + else if(RADIO_ERROR_SOUND_POLICY == err) + { + return UnknownException(buff); + } + else if(RADIO_ERROR_PERMISSION_DENIED == err) + { + return UnknownException(buff); + } + else if(RADIO_ERROR_OUT_OF_MEMORY == err) + { + return UnknownException(buff); + } + else + { + return UnknownException(buff); + } } void FMRadioManager::RadioSeekCB(int frequency, void *user_data) { - RadioSeekCBstruct * data = static_cast(user_data); - double callbackId = data->cbid; - int err = radio_set_frequency(static_cast(data->radio_instance),frequency); + double * id = static_cast(user_data); + + int err = radio_set_frequency(*(FMRadioManager::GetInstance(0)->GetRadioInstance()),frequency); if (RADIO_ERROR_NONE != err) { - createEventFail(callbackId,GetException("radio_set_frequency",err)); + createEventFail(*id,GetException("radio_set_frequency",err)); } else { - createEventSuccess(callbackId); + createEventSuccess(*id); } - delete data; + delete id; +} + +radio_h* FMRadioManager::GetRadioInstance() +{ + return &radio_instance; } void FMRadioManager::SeekUp(const picojson::value& args){ - double callbackId = args.get("callbackId").get(); - RadioSeekCBstruct *data= new RadioSeekCBstruct; - data->cbid = callbackId; - data->radio_instance = radio_instance; - int err = radio_seek_up (radio_instance,RadioSeekCB,static_cast(data)); + double * callbackId = new double(args.get("callbackId").get()); + + int err = radio_seek_up (radio_instance,RadioSeekCB,static_cast(callbackId)); + if(RADIO_ERROR_NONE != err) { - delete data; - createEventFail(callbackId,GetException("radio_set_frequency",err)); - } + delete callbackId; + createEventFail(*callbackId,GetException("radio_set_frequency",err)); + } } void FMRadioManager::SeekDown(const picojson::value& args){ - double callbackId = args.get("callbackId").get(); - RadioSeekCBstruct *data= new RadioSeekCBstruct; - data->cbid = callbackId; - data->radio_instance = radio_instance; - int err = radio_seek_down (radio_instance,RadioSeekCB,static_cast(data)); - if(RADIO_ERROR_NONE != err) - { - delete data; - createEventFail(callbackId,GetException("radio_set_frequency",err)); - } + double * callbackId = new double(args.get("callbackId").get()); + + int err = radio_seek_down (radio_instance,RadioSeekCB,static_cast(callbackId)); + + if(RADIO_ERROR_NONE != err) + { + + delete callbackId; + createEventFail(*callbackId,GetException("radio_set_frequency",err)); + } +} + +void FMRadioManager::ScanStartCB(int frequency, void *user_data) +{ + std::vector * freqs = FMRadioManager::GetInstance()->GetFreqs(); + freqs->push_back(static_cast(frequency)); + + picojson::value event = picojson::value(picojson::object()); + picojson::object& obj = event.get(); + obj.insert(std::make_pair("frequency", picojson::value(static_cast(frequency)))); + obj.insert(std::make_pair("listenerId", "FMRadio_Onfrequencyfound")); + RadioInstance::getInstance().PostMessage(event.serialize().c_str()); + +} + +void FMRadioManager::ScanStopCB(void *user_data) +{ + createEventSuccess( *(static_cast(user_data))); + delete static_cast(user_data); + +} + +std::vector * FMRadioManager::GetFreqs() +{ + return &freqs; +} + +void FMRadioManager::ScanCompleteCB(void *user_data) +{ + double * id= static_cast(user_data); + + std::vector * freqs = FMRadioManager::GetInstance()->GetFreqs(); + + picojson::value event = picojson::value(picojson::object()); + picojson::object& obj = event.get(); + obj.insert(std::make_pair("name", picojson::value("onfinished"))); + + std::vector vect = std::vector (); + for (std::vector::iterator it = freqs->begin() ; it != freqs->end(); ++it) + { + vect.push_back(picojson::value(*it)); + } + + obj.insert(std::make_pair("frequencies", picojson::value(vect))); + createEventSuccess(obj,*id); + + delete id; } -void FMRadioManager::ScanStart(const picojson::value& args){ - LoggerD("FMRadioManager::StartScan()"); + + +void FMRadioManager::ScanStart(const picojson::value& args) +{ + LoggerD("FMRadioManager::ScanStart()"); + + double *callbackId = new double(args.get("callbackId").get()); + + freqs = std::vector(); + + int err =radio_set_scan_completed_cb(radio_instance,ScanCompleteCB,callbackId); + if(err) + { + createEventFail(*callbackId,GetException("radio_set_scan_completed_cb %d",err)); + delete callbackId; + return; + } + + err = radio_scan_start (radio_instance, ScanStartCB, NULL); + if(err) + { + radio_unset_scan_completed_cb(radio_instance); + createEventFail(*callbackId,GetException("radio_scan_start %d",err)); + delete callbackId; + } + } void FMRadioManager::ScanStop(const picojson::value& args){ - LoggerD("FMRadioManager::StopScan()"); + LoggerD("FMRadioManager::ScanStop()"); + + double* callbackId = new double(args.get("callbackId").get()); + + int ret = radio_unset_scan_completed_cb(radio_instance); + if(ret) + { + createEventFail(*callbackId,GetException("radio_unset_scan_completed_cb %d",ret)); + delete callbackId; + return; + } + + ret = radio_scan_stop (radio_instance, ScanStopCB, callbackId); + if(ret) + { + createEventFail(*callbackId,GetException("radio_scan_stop %d",ret)); + delete callbackId; + } + } + +string FMRadioManager::TranslateCode(int code) +{ + if (RADIO_INTERRUPTED_BY_MEDIA == code) + { + return string("RADIO_INTERRUPTED_BY_MEDIA"); + } + else if(RADIO_INTERRUPTED_BY_RESUMABLE_MEDIA == code) + { + return string("RADIO_INTERRUPTED_BY_RESUMABLE_MEDIA"); + } + else if(RADIO_INTERRUPTED_BY_CALL == code) + { + return string("RADIO_INTERRUPTED_BY_CALL"); + } + else if(RADIO_INTERRUPTED_BY_EARJACK_UNPLUG == code) + { + return string("RADIO_INTERRUPTED_BY_EARJACK_UNPLUG"); + } + else if(RADIO_INTERRUPTED_BY_RESOURCE_CONFLICT == code) + { + return string("RADIO_INTERRUPTED_BY_RESOURCE_CONFLICT"); + } + else if(RADIO_INTERRUPTED_BY_ALARM == code) + { + return string("RADIO_INTERRUPTED_BY_ALARM"); + } + else if(RADIO_INTERRUPTED_BY_EMERGENCY == code) + { + return string("RADIO_INTERRUPTED_BY_EMERGENCY"); + } + else if(RADIO_INTERRUPTED_BY_MEDIA == code) + { + return string("RADIO_INTERRUPTED_BY_RESUMABLE_MEDIA"); + } + else if(RADIO_INTERRUPTED_BY_NOTIFICATION == code) + { + return string("RADIO_INTERRUPTED_BY_NOTIFICATION"); + } +} + +void FMRadioManager::RadioInterruptedCB(radio_interrupted_code_e code, void *user_data) +{ + + if(code == RADIO_INTERRUPTED_COMPLETED ) + { + picojson::value event = picojson::value(picojson::object()); + picojson::object& obj = event.get(); + obj.insert(std::make_pair("action", picojson::value("oninterruptfinished"))); + obj.insert(std::make_pair("listenerId", "FMRadio_Interrupted")); + RadioInstance::getInstance().PostMessage(event.serialize().c_str()); + } + else + { + picojson::value event = picojson::value(picojson::object()); + picojson::object& obj = event.get(); + obj.insert(std::make_pair("action", picojson::value("oninterrupted"))); + + obj.insert(std::make_pair("reason", TranslateCode(code))); + + obj.insert(std::make_pair("listenerId", "FMRadio_Interrupted")); + RadioInstance::getInstance().PostMessage(event.serialize().c_str()); + } + +} + void FMRadioManager::SetFMRadioInterruptedListener(){ LoggerD("FMRadioManager::SetFMRadioInterruptedListener()"); + int err = radio_set_interrupted_cb (radio_instance, RadioInterruptedCB, NULL); + if(RADIO_ERROR_NONE != err) + { + CheckErr("radio_set_interrupted_cb",err); + } } void FMRadioManager::UnsetFMRadioInterruptedListener(){ LoggerD("FMRadioManager::UnsetFMRadioInterruptedListener()"); + int err = radio_unset_interrupted_cb(radio_instance); + if(RADIO_ERROR_NONE != err) + { + CheckErr("radio_unset_interrupted_cb",err); + } } + +void FMRadioManager::RadioAntennaCB(runtime_info_key_e key, void *user_data) +{ + LoggerD("FMRadioManager::RadioAntennaCB()"); + + bool connected=false; + int err = runtime_info_get_value_bool (key, &connected); + if(RADIO_ERROR_NONE != err) + { + LoggerE("FMRadioManager::RadioAntennaCB() runtime_info_get_value_bool %d",err); + } + + picojson::value event = picojson::value(picojson::object()); + picojson::object& obj = event.get(); + + obj.insert(std::make_pair("connected", picojson::value(connected))); + + obj.insert(std::make_pair("listenerId", "FMRadio_Antenna")); + RadioInstance::getInstance().PostMessage(event.serialize().c_str()); + +} + void FMRadioManager::SetAntennaChangeListener(){ LoggerD("FMRadioManager::SetAntennaChangeListener()"); + int err = runtime_info_set_changed_cb (RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED , + RadioAntennaCB, NULL); + if(RADIO_ERROR_NONE != err) + { + CheckErr("runtime_info_set_changed_cb",err); + } + } void FMRadioManager::UnsetAntennaChangeListener(){ - LoggerD("FMRadioManager::UnetAntennaChangeListener()"); + LoggerD("FMRadioManager::UnsetAntennaChangeListener()"); + int err = runtime_info_unset_changed_cb (RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED); + if(RADIO_ERROR_NONE != err) + { + CheckErr("runtime_info_unset_changed_cb",err); + } + } } // namespace diff --git a/src/radio/radio_manager.h b/src/radio/radio_manager.h index f38dcbd0..3d1a644c 100755 --- a/src/radio/radio_manager.h +++ b/src/radio/radio_manager.h @@ -10,18 +10,22 @@ #include #include "common/picojson.h" #include "common/platform_exception.h" +#include +#include +#include #include "radio_instance.h" -#include - namespace extension { namespace radio { class FMRadioManager { public: - static FMRadioManager* GetInstance(); + static FMRadioManager* GetInstance(bool safe = true); + + radio_h * GetRadioInstance(); + std::vector * GetFreqs(); void Start(double freq); void Stop(); @@ -34,23 +38,30 @@ public: void SetAntennaChangeListener(); void UnsetAntennaChangeListener(); + bool MuteGetter(); + void MuteSetter(const picojson::value& args); double FrequencyGetter(); double SignalStrengthGetter(); + bool AntennaGetter(); + char* StateGetter(); private: + std::vector freqs; + radio_h radio_instance; + static std::string TranslateCode(int err); + static void RadioAntennaCB(runtime_info_key_e key, void *user_data); + static void RadioInterruptedCB(radio_interrupted_code_e code, void *user_data); static common::PlatformException GetException(char * name,int err); static void RadioSeekCB(int frequency, void *user_data); static void CheckErr(std::string str,int err); - - radio_h radio_instance; - + static void ScanStartCB(int frequency, void *user_data); + static void ScanStopCB(void *user_data); + static void ScanCompleteCB(void *user_data); int Create(); - FMRadioManager(); ~FMRadioManager(); - }; } // namespace -- 2.34.1