#include <functional>
-#include "common/picojson.h"
+#include <radio.h>
+
#include "common/logger.h"
#include "common/platform_exception.h"
-#include <radio.h>
+#include "radio/radio_manager.h"
namespace extension {
namespace radio {
- using namespace common;
- using namespace extension::radio;
-
- RadioInstance::RadioInstance() {
- using namespace std::placeholders;
- #define REGISTER_SYNC(c,x) \
- RegisterSyncHandler(c, std::bind(&RadioInstance::x, this, _1, _2));
- REGISTER_SYNC("FMRadio_Start", Start);
- REGISTER_SYNC("FMRadio_Stop", Stop);
- REGISTER_SYNC("FMRadio_SetFMRadioInterruptedListener", SetFMRadioInterruptedListener);
- REGISTER_SYNC("FMRadio_UnsetFMRadioInterruptedListener", UnsetFMRadioInterruptedListener);
- REGISTER_SYNC("FMRadio_SetAntennaChangeListener", SetAntennaChangeListener);
- REGISTER_SYNC("FMRadio_UnsetAntennaChangeListener", UnsetAntennaChangeListener);
- REGISTER_SYNC("FMRadio_FrequencyGetter", FrequencyGetter);
- REGISTER_SYNC("FMRadio_SignalStrengthGetter", SignalStrengthGetter);
- 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));
- REGISTER_ASYNC("FMRadio_SeekUp", SeekUp);
- REGISTER_ASYNC("FMRadio_SeekDown", SeekDown);
- REGISTER_ASYNC("FMRadio_ScanStart", ScanStart);
- REGISTER_ASYNC("FMRadio_ScanStop", ScanStop);
- #undef REGISTER_ASYNC
-
- LoggerD("RadioInstance()");
- }
-
- RadioInstance::~RadioInstance() {
- }
-
- RadioInstance& RadioInstance::getInstance() {
- static RadioInstance instance;
- return instance;
- }
-
- 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)
- {
- 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(0)->FrequencyGetter();
- ReportSuccess(picojson::value(freq),out);
- }
-
- void RadioInstance::SignalStrengthGetter(const picojson::value& args,
- picojson::object& out)
- {
- LoggerD(".cc SignalStrengthGetter()");
- double strength = FMRadioManager::GetInstance(0)->SignalStrengthGetter();
- ReportSuccess(picojson::value(strength),out);
- }
-
- void RadioInstance::InstanceReportSuccess(picojson::object& out) {
- LoggerD(".cc InstanceReportSuccess()");
- }
-
- void RadioInstance::SeekUp(const picojson::value& args,
- picojson::object& out) {
- LoggerD(".cc SeekUp()");
- FMRadioManager::GetInstance(0)->SeekUp(args);
- }
-
- void RadioInstance::SeekDown(const picojson::value& args,
- picojson::object& out) {
- LoggerD(".cc SeekDown()");
- FMRadioManager::GetInstance(0)->SeekDown(args);
- }
-
- void RadioInstance::Start(const picojson::value& args,
- picojson::object& out) {
- try{
- LoggerD(".cc RadioInstance::Start()");
- FMRadioManager::GetInstance()->Start(args.get("frequency").get<double>());
- }
- catch(const PlatformException& e){
- ReportError(e,out);
- }
- }
-
- void RadioInstance::Stop(const picojson::value& args,
- picojson::object& out) {
- try{
- LoggerD(".cc Stop()");
- FMRadioManager::GetInstance()->Stop();
- }
- catch(const PlatformException& e){
- ReportError(e,out);
- }
- }
-
- void RadioInstance::ScanStart(const picojson::value& args,
- picojson::object& out) {
- FMRadioManager::GetInstance(0)->ScanStart(args);
- }
-
- void RadioInstance::ScanStop(const picojson::value& args,
- picojson::object& out) {
- FMRadioManager::GetInstance(0)->ScanStop(args);
- }
-
- void RadioInstance::SetFMRadioInterruptedListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD(".cc SetFMRadioInterruptedListener()");
- FMRadioManager::GetInstance(0)->SetFMRadioInterruptedListener();
- }
-
- void RadioInstance::UnsetFMRadioInterruptedListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD(".cc UnsetFMRadioInterruptedListener()");
- FMRadioManager::GetInstance(0)->UnsetFMRadioInterruptedListener();
- }
-
- void RadioInstance::SetAntennaChangeListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD(".cc SetAntennaChangeListener()");
- FMRadioManager::GetInstance(0)->SetAntennaChangeListener();
- }
-
- void RadioInstance::UnsetAntennaChangeListener(const picojson::value& args,
- picojson::object& out) {
- LoggerD(".cc UnsetAntennaChangeListener()");
- FMRadioManager::GetInstance(0)->UnsetAntennaChangeListener();
- }
+using namespace common;
+using namespace extension::radio;
+
+RadioInstance::RadioInstance() {
+ using namespace std::placeholders;
+ #define REGISTER_SYNC(c,x) \
+ RegisterSyncHandler(c, std::bind(&RadioInstance::x, this, _1, _2));
+ REGISTER_SYNC("FMRadio_Start", Start);
+ REGISTER_SYNC("FMRadio_Stop", Stop);
+ REGISTER_SYNC("FMRadio_SetFMRadioInterruptedListener", SetFMRadioInterruptedListener);
+ REGISTER_SYNC("FMRadio_UnsetFMRadioInterruptedListener", UnsetFMRadioInterruptedListener);
+ REGISTER_SYNC("FMRadio_SetAntennaChangeListener", SetAntennaChangeListener);
+ REGISTER_SYNC("FMRadio_UnsetAntennaChangeListener", UnsetAntennaChangeListener);
+ REGISTER_SYNC("FMRadio_FrequencyGetter", FrequencyGetter);
+ REGISTER_SYNC("FMRadio_SignalStrengthGetter", SignalStrengthGetter);
+ 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));
+ REGISTER_ASYNC("FMRadio_SeekUp", SeekUp);
+ REGISTER_ASYNC("FMRadio_SeekDown", SeekDown);
+ REGISTER_ASYNC("FMRadio_ScanStart", ScanStart);
+ REGISTER_ASYNC("FMRadio_ScanStop", ScanStop);
+ #undef REGISTER_ASYNC
+
+ LoggerD("RadioInstance()");
+}
+
+RadioInstance::~RadioInstance() {
+}
+
+RadioInstance& RadioInstance::getInstance() {
+ static RadioInstance instance;
+ return instance;
+}
+
+void RadioInstance::MuteGetter(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ ReportSuccess(picojson::value(FMRadioManager::GetInstance()->IsMuted()), out);
+}
+
+void RadioInstance::MuteSetter(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ FMRadioManager::GetInstance()->SetMute(args.get("mute").get<bool>());
+ ReportSuccess(out);
+}
+
+void RadioInstance::AntennaGetter(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ ReportSuccess(picojson::value(FMRadioManager::GetInstance()->HasAntenna()),
+ out);
+}
+
+void RadioInstance::StateGetter(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ ReportSuccess(picojson::value(FMRadioManager::GetInstance()->GetState()),
+ out);
+}
+
+void RadioInstance::FrequencyGetter(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ ReportSuccess(picojson::value(FMRadioManager::GetInstance()->GetFrequency()),
+ out);
+}
+
+void RadioInstance::SignalStrengthGetter(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ ReportSuccess(picojson::value(FMRadioManager::GetInstance()->GetSignalStrength()),
+ out);
+}
+
+void RadioInstance::SeekUp(const picojson::value& args, picojson::object& out) {
+ LoggerD("Enter");
+ FMRadioManager::GetInstance()->SeekUp(args.get("callbackId").get<double>());
+ ReportSuccess(out);
+}
+
+void RadioInstance::SeekDown(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ FMRadioManager::GetInstance()->SeekDown(args.get("callbackId").get<double>());
+ ReportSuccess(out);
+}
+void RadioInstance::Start(const picojson::value& args, picojson::object& out) {
+ LoggerD("Enter");
+ try {
+ FMRadioManager::GetInstance()->Start(args.get("frequency").get<double>());
+ ReportSuccess(out);
+ } catch (const PlatformException& e) {
+ ReportError(e, out);
+ }
}
+
+void RadioInstance::Stop(const picojson::value& args, picojson::object& out) {
+ LoggerD("Enter");
+ try {
+ FMRadioManager::GetInstance()->Stop();
+ ReportSuccess(out);
+ } catch (const PlatformException& e) {
+ ReportError(e, out);
+ }
+}
+
+void RadioInstance::ScanStart(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ FMRadioManager::GetInstance()->ScanStart(args.get("callbackId").get<double>());
+ ReportSuccess(out);
+}
+
+void RadioInstance::ScanStop(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ FMRadioManager::GetInstance()->ScanStop(args.get("callbackId").get<double>());
+ ReportSuccess(out);
}
+
+void RadioInstance::SetFMRadioInterruptedListener(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ FMRadioManager::GetInstance()->SetFMRadioInterruptedListener();
+ ReportSuccess(out);
+}
+
+void RadioInstance::UnsetFMRadioInterruptedListener(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ FMRadioManager::GetInstance()->UnsetFMRadioInterruptedListener();
+ ReportSuccess(out);
+}
+
+void RadioInstance::SetAntennaChangeListener(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ FMRadioManager::GetInstance()->SetAntennaChangeListener();
+ ReportSuccess(out);
+}
+
+void RadioInstance::UnsetAntennaChangeListener(const picojson::value& args,
+ picojson::object& out) {
+ LoggerD("Enter");
+ FMRadioManager::GetInstance()->UnsetAntennaChangeListener();
+ ReportSuccess(out);
+}
+
+} // namespace radio
+} // namespace extension
namespace extension {
namespace radio {
-char* state_array[] = { "READY", "PLAYING", "SCANNING" ,""};
+namespace {
+
+const char* RADIO_STATE_ERROR = "ERROR";
+std::map<radio_state_e, const char*> radio_state = {
+ { RADIO_STATE_READY, "READY" },
+ { RADIO_STATE_PLAYING, "PLAYING" },
+ { RADIO_STATE_SCANNING, "SCANNING" },
+};
static const double FREQ_LOWER = 87.5;
-static void createEventSuccess(picojson::object& obj,double callbackId)
-{
- obj.insert(std::make_pair("callbackId", callbackId));
- obj.insert(std::make_pair("status", picojson::value("success")));
+static void AddCallbackID(double callbackId, picojson::object* obj) {
+ obj->insert(std::make_pair("callbackId", callbackId));
+}
+
+static void PostResultSuccess(double callbackId, picojson::value* event) {
+ auto& obj = event->get<picojson::object>();
+
+ tools::ReportSuccess(obj);
+ AddCallbackID(callbackId, &obj);
- picojson::value event = picojson::value(obj);
- RadioInstance::getInstance().PostMessage(event.serialize().c_str());
+ RadioInstance::getInstance().PostMessage(event->serialize().c_str());
}
-static void createEventSuccess(double callbackId)
-{
- picojson::value event = picojson::value(picojson::object());
- picojson::object& obj = event.get<picojson::object>();
+static void PostResultSuccess(double callbackId) {
+ picojson::value event{picojson::object()};
- createEventSuccess(obj,callbackId);
+ PostResultSuccess(callbackId, &event);
}
+static void PostResultFailure(double callbackId, const PlatformException& ex) {
+ picojson::value event{picojson::object()};
+ auto& obj = event.get<picojson::object>();
-static void createEventFail(double callbackId,const PlatformException& ex)
-{
+ tools::ReportError(ex, obj);
+ AddCallbackID(callbackId, &obj);
- picojson::value event = picojson::value(picojson::object());
- picojson::object& obj = event.get<picojson::object>();
+ RadioInstance::getInstance().PostMessage(event.serialize().c_str());
+}
- obj.insert(std::make_pair("error", ex.ToJSON()));
- obj.insert(std::make_pair("callbackId", callbackId));
- obj.insert(std::make_pair("status", picojson::value("error")));
+PlatformException GetException(const std::string& str, int err) {
+ LoggerD("Enter");
- RadioInstance::getInstance().PostMessage(event.serialize().c_str());
- }
+ string message = str + " : " + to_string(err);
-int FMRadioManager::Create()
-{
- if (radio_instance == NULL)
- {
- int err = radio_create(&radio_instance);
- if(err){
- LoggerE("radio_create %d",err);
- radio_instance=NULL;
- }
- return err;
- }
- return 0;
-}
+ switch (err) {
+ case RADIO_ERROR_INVALID_PARAMETER:
+ return InvalidValuesException(message);
-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;
-}
+ case RADIO_ERROR_INVALID_STATE:
+ return InvalidStateException(message);
-void FMRadioManager::MuteSetter(const picojson::value& args)
-{
- bool mute = args.get("mute").get<bool>();
+ case RADIO_ERROR_NOT_SUPPORTED:
+ return ServiceNotAvailableException(message);
- int err = radio_set_mute (radio_instance, mute);
- if (err)
- {
- LoggerE("radio_set_mute %d",err);
- }
+ default:
+ return UnknownException(message);
+ }
}
-bool FMRadioManager::AntennaGetter()
-{
- bool connected = false;
- int err = runtime_info_get_value_bool (RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED , &connected);
+void CheckError(const std::string& str, int err) {
+ LoggerE("%s() error %d", str.c_str(), err);
- if (err)
- {
- return false;
- }
- return connected;
+ switch (err) {
+ case RADIO_ERROR_NONE:
+ break;
+
+ default:
+ throw GetException(str, err);
+ break;
+ }
+}
+
+string TranslateInterruptedCode(int code) {
+ LoggerD("Enter");
+#define STRINGIFY(c) case c: return #c
+ switch (code) {
+ STRINGIFY(RADIO_INTERRUPTED_BY_MEDIA);
+ STRINGIFY(RADIO_INTERRUPTED_BY_CALL);
+ STRINGIFY(RADIO_INTERRUPTED_BY_EARJACK_UNPLUG);
+ STRINGIFY(RADIO_INTERRUPTED_BY_RESOURCE_CONFLICT);
+ STRINGIFY(RADIO_INTERRUPTED_BY_ALARM);
+ STRINGIFY(RADIO_INTERRUPTED_BY_EMERGENCY);
+ STRINGIFY(RADIO_INTERRUPTED_BY_RESUMABLE_MEDIA);
+ STRINGIFY(RADIO_INTERRUPTED_BY_NOTIFICATION);
+ default: return "UNKNOWN_INTERRUPTED_ERROR_CODE";
+ }
+#undef STRINGIFY
}
+int TokHz(double frequency) {
+ return static_cast<int>(frequency * 1000.0);
+}
+double ToMHz(int frequency) {
+ return static_cast<double>(frequency) / 1000.0;
+}
-char* FMRadioManager::StateGetter()
-{
- LoggerD("FMRadioManager::FrequencyGetter()");
+void RadioSeekCallback(int frequency, void* user_data) {
+ LoggerD("Enter");
- radio_state_e state;
+ double* id = static_cast<double*>(user_data);
- int err = radio_get_state (radio_instance, &state);
- if (err)
- {
- return state_array[3]; // returns ""
- }
+ try {
+ FMRadioManager::GetInstance()->SetFrequency(ToMHz(frequency));
+ PostResultSuccess(*id);
+ } catch (const PlatformException& ex) {
+ PostResultFailure(*id, ex);
+ }
- return state_array[static_cast<int>(state)];
+ delete id;
}
-double FMRadioManager::FrequencyGetter()
-{
- int freq;
- LoggerD("FMRadioManager::FrequencyGetter()");
- int err = radio_get_frequency(radio_instance,&freq);
+struct ScanData {
+ double callback_id_;
+ std::vector<int> frequencies_;
+};
- if (RADIO_ERROR_NONE != err)
- {
- LoggerE("radio_get_frequency() error %d",err);
- return FREQ_LOWER;
- }
- return static_cast<double>(freq/1000);
+void ScanStartCallback(int frequency, void* user_data) {
+ LoggerD("Enter");
+
+ ScanData* data = static_cast<ScanData*>(user_data);
+ data->frequencies_.push_back(frequency);
+
+ picojson::value event{picojson::object()};
+ auto& obj = event.get<picojson::object>();
+ obj.insert(std::make_pair("frequency", picojson::value(ToMHz(frequency))));
+ obj.insert(std::make_pair("listenerId", "FMRadio_Onfrequencyfound"));
+ RadioInstance::getInstance().PostMessage(event.serialize().c_str());
}
-double FMRadioManager::SignalStrengthGetter()
-{
- int stren;
+void ScanCompleteCallback(void* user_data) {
+ LoggerD("Enter");
- LoggerD("FMRadioManager::SignalStrengthGetter()");
- int err = radio_get_signal_strength(radio_instance,&stren);
- if (RADIO_ERROR_NONE != err)
- {
- LoggerE("radio_get_signal_strength()");
- return 0;
- }
+ ScanData* data = static_cast<ScanData*>(user_data);
- return static_cast<double>(stren);
-}
+ picojson::value event{picojson::object()};
+ auto& obj = event.get<picojson::object>();
+ obj.insert(std::make_pair("name", picojson::value("onfinished")));
-FMRadioManager::FMRadioManager() : radio_instance(NULL)
-{
- LoggerD("FMRadioManager::FMRadioManager()");
+ picojson::array frequencies;
+ for (auto frequency : data->frequencies_) {
+ frequencies.push_back(picojson::value(ToMHz(frequency)));
+ }
+
+ obj.insert(std::make_pair("frequencies", picojson::value(frequencies)));
+ PostResultSuccess(data->callback_id_, &event);
+
+ delete data;
}
-FMRadioManager::~FMRadioManager()
-{
+void ScanStopCallback(void *user_data) {
+ LoggerD("Enter");
+ double* callback_id = static_cast<double*>(user_data);
- LoggerD("FMRadioManager::~FMRadioManager()");
- int err = radio_destroy(radio_instance);
- LoggerD("radio_destroy() error %d",err);
+ PostResultSuccess(*callback_id);
+ delete callback_id;
}
-FMRadioManager* FMRadioManager::GetInstance(bool safe)
-{
+void RadioInterruptedCallback(radio_interrupted_code_e code, void *user_data) {
+ LoggerD("Enter");
- static FMRadioManager instance;
+ picojson::value event{picojson::object()};
+ auto& obj = event.get<picojson::object>();
- int err=instance.Create();
- if(safe)
- {
- CheckErr("radio_create",err);
- }
- LoggerD("FMRadioManager::GetInstance()");
+ obj.insert(std::make_pair("listenerId", "FMRadio_Interrupted"));
- return &instance;
+ if (code == RADIO_INTERRUPTED_COMPLETED) {
+ obj.insert(
+ std::make_pair("action", picojson::value("oninterruptfinished")));
+ } else {
+ obj.insert(std::make_pair("action", picojson::value("oninterrupted")));
+ obj.insert(std::make_pair("reason", TranslateInterruptedCode(code)));
+ }
+
+ RadioInstance::getInstance().PostMessage(event.serialize().c_str());
}
-void FMRadioManager::CheckErr(string str,int err)
-{
- LoggerE("%s() error %d",str.c_str(),err);
+void RadioAntennaCallback(runtime_info_key_e key, void* user_data) {
+ LoggerD("Enter");
- if(RADIO_ERROR_NONE == err)
- {
- return;
- }
- else if (RADIO_ERROR_INVALID_PARAMETER == err)
- {
- throw common::InvalidValuesException(str);
- }
- else if(RADIO_ERROR_INVALID_STATE == err)
- {
- throw common::InvalidStateException(str);
- }
- else if(RADIO_ERROR_SOUND_POLICY == err)
- {
- throw common::UnknownException(str);
- }
- else if(RADIO_ERROR_NOT_SUPPORTED == err)
- {
- throw common::ServiceNotAvailableException(str);
- }
- else
- {
- throw common::UnknownException(str);
- }
+ bool connected = false;
+ const auto err = runtime_info_get_value_bool(key, &connected);
+ if (RADIO_ERROR_NONE != err) {
+ LoggerE("runtime_info_get_value_bool() failed: %d", err);
+ }
+
+ picojson::value event{picojson::object()};
+ auto& obj = event.get<picojson::object>();
+ 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::Start(double freq)
-{
- LoggerD("FMRadioManager::Start(%f)",freq);
+} // namespace
- int err = radio_set_frequency (radio_instance, freq*1000);
- CheckErr("radio_set_frequency",err);
+bool FMRadioManager::IsMuted() {
+ LoggerD("Enter");
- err= radio_start(radio_instance);
- CheckErr("radio_start",err);
-}
+ bool muted = false;
+ const auto err = radio_is_muted(radio_instance_, &muted);
-void FMRadioManager::Stop()
-{
- int err= radio_stop(radio_instance);
- CheckErr("radio_stop",err);
+ if (RADIO_ERROR_NONE != err) {
+ LoggerE("radio_is_muted() failed: %d", err);
+ }
+
+ return muted;
}
-PlatformException FMRadioManager::GetException(char * name,int err)
-{
+void FMRadioManager::SetMute(bool mute) {
+ LoggerD("Enter");
- string buff=string(name);
- buff+=" : ";
- buff+=to_string(err);
+ const auto err = radio_set_mute(radio_instance_, mute);
- 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);
- }
+ if (RADIO_ERROR_NONE != err) {
+ LoggerE("radio_set_mute() failed: %d", err);
+ }
}
-void FMRadioManager::RadioSeekCB(int frequency, void *user_data)
-{
- double * id = static_cast<double*>(user_data);
+bool FMRadioManager::HasAntenna() {
+ LoggerD("Enter");
- int err = radio_set_frequency(*(FMRadioManager::GetInstance(0)->GetRadioInstance()),frequency);
+ bool connected = false;
+ const auto err = runtime_info_get_value_bool(RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED,
+ &connected);
- if (RADIO_ERROR_NONE != err)
- {
- createEventFail(*id,GetException("radio_set_frequency",err));
- }
- else
- {
- createEventSuccess(*id);
- }
+ if (RUNTIME_INFO_ERROR_NONE != err) {
+ LoggerE("runtime_info_get_value_bool() failed: %d", err);
+ }
- delete id;
+ return connected;
}
-radio_h* FMRadioManager::GetRadioInstance()
-{
- return &radio_instance;
-}
+const char* FMRadioManager::GetState() {
+ LoggerD("Enter");
-void FMRadioManager::SeekUp(const picojson::value& args){
+ radio_state_e state;
- double * callbackId = new double(args.get("callbackId").get<double>());
+ const auto err = radio_get_state(radio_instance_, &state);
- int err = radio_seek_up (radio_instance,RadioSeekCB,static_cast<void *>(callbackId));
+ if (RADIO_ERROR_NONE != err) {
+ LoggerE("radio_get_state() failed: %d", err);
+ return RADIO_STATE_ERROR;
+ }
- if(RADIO_ERROR_NONE != err)
- {
+ const auto s = radio_state.find(state);
- delete callbackId;
- createEventFail(*callbackId,GetException("radio_set_frequency",err));
- }
+ if (radio_state.end() != s) {
+ return s->second;
+ } else {
+ LoggerE("Unknown state: %d", state);
+ return RADIO_STATE_ERROR;
+ }
}
-void FMRadioManager::SeekDown(const picojson::value& args){
+void FMRadioManager::SetFrequency(double frequency) {
+ LoggerD("Enter");
- double * callbackId = new double(args.get("callbackId").get<double>());
+ auto err = radio_set_frequency(radio_instance_, TokHz(frequency));
+ CheckError("radio_set_frequency", err);
+}
- int err = radio_seek_down (radio_instance,RadioSeekCB,static_cast<void *>(callbackId));
+double FMRadioManager::GetFrequency() {
+ LoggerD("Enter");
- if(RADIO_ERROR_NONE != err)
- {
+ int frequency = 0;
+ const auto err = radio_get_frequency(radio_instance_, &frequency);
- delete callbackId;
- createEventFail(*callbackId,GetException("radio_set_frequency",err));
- }
+ if (RADIO_ERROR_NONE != err) {
+ LoggerE("radio_get_frequency() failed: %d", err);
+ return FREQ_LOWER;
+ } else {
+ return ToMHz(frequency);
+ }
}
-void FMRadioManager::ScanStartCB(int frequency, void *user_data)
-{
- std::vector<double> * freqs = FMRadioManager::GetInstance()->GetFreqs();
- freqs->push_back(static_cast<double>(frequency));
+double FMRadioManager::GetSignalStrength() {
+ LoggerD("Enter");
- picojson::value event = picojson::value(picojson::object());
- picojson::object& obj = event.get<picojson::object>();
- obj.insert(std::make_pair("frequency", picojson::value(static_cast<double>(frequency))));
- obj.insert(std::make_pair("listenerId", "FMRadio_Onfrequencyfound"));
- RadioInstance::getInstance().PostMessage(event.serialize().c_str());
+ int strength = 0;
+ const auto err = radio_get_signal_strength(radio_instance_, &strength);
+ if (RADIO_ERROR_NONE != err) {
+ LoggerE("radio_get_signal_strength() failed: %d", err);
+ return 0;
+ } else {
+ return strength;
+ }
}
-void FMRadioManager::ScanStopCB(void *user_data)
-{
- createEventSuccess( *(static_cast<double*>(user_data)));
- delete static_cast<double*>(user_data);
+FMRadioManager::FMRadioManager()
+ : radio_instance_(nullptr) {
+ LoggerD("Enter");
-}
+ const auto err = radio_create(&radio_instance_);
-std::vector<double> * FMRadioManager::GetFreqs()
-{
- return &freqs;
+ if (RADIO_ERROR_NONE != err) {
+ LoggerE("radio_create() failed: %d", err);
+ radio_instance_ = nullptr;
+ }
}
-void FMRadioManager::ScanCompleteCB(void *user_data)
-{
- double * id= static_cast<double*>(user_data);
-
- std::vector<double> * freqs = FMRadioManager::GetInstance()->GetFreqs();
+FMRadioManager::~FMRadioManager() {
+ LoggerD("Enter");
- picojson::value event = picojson::value(picojson::object());
- picojson::object& obj = event.get<picojson::object>();
- obj.insert(std::make_pair("name", picojson::value("onfinished")));
+ if (radio_instance_) {
+ const auto err = radio_destroy(radio_instance_);
- std::vector<picojson::value> vect = std::vector<picojson::value> ();
- for (std::vector<double>::iterator it = freqs->begin() ; it != freqs->end(); ++it)
- {
- vect.push_back(picojson::value(*it));
+ if (RADIO_ERROR_NONE != err) {
+ LoggerE("radio_destroy() failed: %d", err);
}
- obj.insert(std::make_pair("frequencies", picojson::value(vect)));
- createEventSuccess(obj,*id);
-
- delete id;
+ radio_instance_ = nullptr;
+ }
}
+FMRadioManager* FMRadioManager::GetInstance() {
+ LoggerD("Enter");
+ static FMRadioManager instance;
+ return &instance;
+}
-void FMRadioManager::ScanStart(const picojson::value& args)
-{
- LoggerD("FMRadioManager::ScanStart()");
-
- double *callbackId = new double(args.get("callbackId").get<double>());
+void FMRadioManager::Start(double frequency) {
+ LoggerD("Enter, frequency: %f", frequency);
- freqs = std::vector<double>();
+ SetFrequency(frequency);
- 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;
- }
+ auto err = radio_start(radio_instance_);
+ CheckError("radio_start", err);
+}
- 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::Stop() {
+ LoggerD("Enter");
+ const auto err = radio_stop(radio_instance_);
+ CheckError("radio_stop", err);
}
-void FMRadioManager::ScanStop(const picojson::value& args){
- LoggerD("FMRadioManager::ScanStop()");
- double* callbackId = new double(args.get("callbackId").get<double>());
+void FMRadioManager::SeekUp(double callback_id) {
+ LoggerD("Enter");
- int ret = radio_unset_scan_completed_cb(radio_instance);
- if(ret)
- {
- createEventFail(*callbackId,GetException("radio_unset_scan_completed_cb %d",ret));
- delete callbackId;
- return;
- }
+ double* user_data = new double(callback_id);
- ret = radio_scan_stop (radio_instance, ScanStopCB, callbackId);
- if(ret)
- {
- createEventFail(*callbackId,GetException("radio_scan_stop %d",ret));
- delete callbackId;
- }
+ const auto err = radio_seek_up(radio_instance_, RadioSeekCallback, user_data);
+ if (RADIO_ERROR_NONE != err) {
+ delete user_data;
+ PostResultFailure(*user_data, GetException("radio_seek_up", err));
+ }
}
-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::SeekDown(double callback_id) {
+ LoggerD("Enter");
-void FMRadioManager::RadioInterruptedCB(radio_interrupted_code_e code, void *user_data)
-{
+ double* user_data = new double(callback_id);
- if(code == RADIO_INTERRUPTED_COMPLETED )
- {
- picojson::value event = picojson::value(picojson::object());
- picojson::object& obj = event.get<picojson::object>();
- 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<picojson::object>();
- obj.insert(std::make_pair("action", picojson::value("oninterrupted")));
+ const auto err = radio_seek_down(radio_instance_, RadioSeekCallback, user_data);
- obj.insert(std::make_pair("reason", TranslateCode(code)));
+ if (RADIO_ERROR_NONE != err) {
+ delete user_data;
+ PostResultFailure(*user_data, GetException("radio_seek_down", err));
+ }
+}
- obj.insert(std::make_pair("listenerId", "FMRadio_Interrupted"));
- RadioInstance::getInstance().PostMessage(event.serialize().c_str());
- }
+void FMRadioManager::ScanStart(double callback_id) {
+ LoggerD("Enter");
-}
+ ScanData* user_data = new ScanData();
+ user_data->callback_id_ = callback_id;
-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);
- }
+ auto err = radio_set_scan_completed_cb(radio_instance_, ScanCompleteCallback,
+ user_data);
+ if (RADIO_ERROR_NONE != err) {
+ PostResultFailure(callback_id,
+ GetException("radio_set_scan_completed_cb", err));
+ delete user_data;
+ return;
+ }
+
+ err = radio_scan_start(radio_instance_, ScanStartCallback, user_data);
+ if (RADIO_ERROR_NONE != err) {
+ radio_unset_scan_completed_cb(radio_instance_);
+ PostResultFailure(callback_id, GetException("radio_scan_start", err));
+ delete user_data;
+ }
}
-void FMRadioManager::RadioAntennaCB(runtime_info_key_e key, void *user_data)
-{
- LoggerD("FMRadioManager::RadioAntennaCB()");
+void FMRadioManager::ScanStop(double callback_id) {
+ LoggerD("Enter");
- 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);
- }
+ double* user_data = new double(callback_id);
- picojson::value event = picojson::value(picojson::object());
- picojson::object& obj = event.get<picojson::object>();
+ auto err = radio_unset_scan_completed_cb(radio_instance_);
+ if (RADIO_ERROR_NONE != err) {
+ PostResultFailure(*user_data,
+ GetException("radio_unset_scan_completed_cb", err));
+ delete user_data;
+ return;
+ }
- obj.insert(std::make_pair("connected", picojson::value(connected)));
+ err = radio_scan_stop(radio_instance_, ScanStopCallback, user_data);
+ if (RADIO_ERROR_NONE != err) {
+ PostResultFailure(*user_data, GetException("radio_scan_stop", err));
+ delete user_data;
+ }
+}
- obj.insert(std::make_pair("listenerId", "FMRadio_Antenna"));
- RadioInstance::getInstance().PostMessage(event.serialize().c_str());
+void FMRadioManager::SetFMRadioInterruptedListener() {
+ LoggerD("Enter");
+ const auto err = radio_set_interrupted_cb(radio_instance_,
+ RadioInterruptedCallback,
+ nullptr);
+ if (RADIO_ERROR_NONE != err) {
+ CheckError("radio_set_interrupted_cb", err);
+ }
}
-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::UnsetFMRadioInterruptedListener() {
+ LoggerD("Enter");
+ const auto err = radio_unset_interrupted_cb(radio_instance_);
+ if (RADIO_ERROR_NONE != err) {
+ CheckError("radio_unset_interrupted_cb", err);
+ }
}
-void FMRadioManager::UnsetAntennaChangeListener(){
- 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);
- }
+void FMRadioManager::SetAntennaChangeListener() {
+ LoggerD("Enter");
+
+ const auto err = runtime_info_set_changed_cb(
+ RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED,
+ RadioAntennaCallback,
+ nullptr);
+ if (RADIO_ERROR_NONE != err) {
+ CheckError("runtime_info_set_changed_cb", err);
+ }
}
-} // namespace
+void FMRadioManager::UnsetAntennaChangeListener() {
+ LoggerD("Enter");
+
+ const auto err = runtime_info_unset_changed_cb(
+ RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED);
+ if (RADIO_ERROR_NONE != err) {
+ CheckError("runtime_info_unset_changed_cb", err);
+ }
+}
+
+} // namespace radio
} // namespace extension
projects / platform / core / api / webapi-plugins.git / commitdiff