From: Pawel Andruszkiewicz <p.andruszkie@samsung.com>
Date: Tue, 10 Feb 2015 09:09:01 +0000 (+0100)
Subject: [FMRadio] Major C++ code refactoring.
X-Git-Tag: submit/tizen_tv/20150603.064601~1^2~429
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=5ed78c5b30ac8b791858d6a778edbc2fa0da6afd;p=platform%2Fcore%2Fapi%2Fwebapi-plugins.git

[FMRadio] Major C++ code refactoring.

Change-Id: I75d87366fbca2ea297decd7eba8bbc1d8e483643
---

diff --git a/src/radio/radio_extension.cc b/src/radio/radio_extension.cc
index ae9f6eeb..664873e4 100644
--- a/src/radio/radio_extension.cc
+++ b/src/radio/radio_extension.cc
@@ -20,8 +20,9 @@ RadioExtension::RadioExtension() {
   LoggerD("RadioExtension()");
 }
 
-RadioExtension::~RadioExtension() {}
+RadioExtension::~RadioExtension() {
+}
 
 common::Instance* RadioExtension::CreateInstance() {
-    return &extension::radio::RadioInstance::getInstance();
+  return &extension::radio::RadioInstance::getInstance();
 }
diff --git a/src/radio/radio_extension.h b/src/radio/radio_extension.h
index 6d468311..265376f2 100644
--- a/src/radio/radio_extension.h
+++ b/src/radio/radio_extension.h
@@ -7,14 +7,13 @@
 
 #include "common/extension.h"
 
-class RadioExtension : public common::Extension
-{
-    public:
-    RadioExtension();
-    virtual ~RadioExtension();
+class RadioExtension : public common::Extension {
+ public:
+  RadioExtension();
+  virtual ~RadioExtension();
 
-    private:
-    virtual common::Instance* CreateInstance();
+ private:
+  virtual common::Instance* CreateInstance();
 };
 
 #endif //RADIO_RADIO_EXTENSION_H_
diff --git a/src/radio/radio_instance.cc b/src/radio/radio_instance.cc
index d02b6011..6e2aa428 100644
--- a/src/radio/radio_instance.cc
+++ b/src/radio/radio_instance.cc
@@ -6,170 +6,170 @@
 
 #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
diff --git a/src/radio/radio_instance.h b/src/radio/radio_instance.h
index fef4d201..448f11c1 100644
--- a/src/radio/radio_instance.h
+++ b/src/radio/radio_instance.h
@@ -6,30 +6,25 @@
 #define RADIO_RADIO_INSTANCE_H_
 
 #include "common/extension.h"
-#include "radio_manager.h"
 #include "common/picojson.h"
 
 namespace extension {
 namespace radio {
 
-class RadioInstance
-    : public common::ParsedInstance
-      {
+class RadioInstance : public common::ParsedInstance {
  public:
   RadioInstance();
   virtual ~RadioInstance();
 
   static RadioInstance& getInstance();
 
-  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 AntennaGetter(const picojson::value& args,picojson::object& out);
-  void StateGetter(const picojson::value& args,picojson::object& out);
+  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 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);
   void ScanStart(const picojson::value& args, picojson::object& out);
@@ -42,7 +37,7 @@ class RadioInstance
   void UnsetAntennaChangeListener(const picojson::value& args, picojson::object& out);
 };
 
-}
-}
+} // namespace radio
+} // namespace extension
 
 #endif
diff --git a/src/radio/radio_manager.cc b/src/radio/radio_manager.cc
index c7de995a..3f0f4601 100755
--- a/src/radio/radio_manager.cc
+++ b/src/radio/radio_manager.cc
@@ -21,518 +21,458 @@ using namespace std;
 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
 
diff --git a/src/radio/radio_manager.h b/src/radio/radio_manager.h
index 3d1a644c..05aaff5e 100755
--- a/src/radio/radio_manager.h
+++ b/src/radio/radio_manager.h
@@ -5,14 +5,15 @@
 #ifndef FMRADIO_FMRADIO_MANAGER_H_
 #define FMRADIO_FMRADIO_MANAGER_H_
 
-#include <string>
 #include <list>
-#include <device/callback.h>
-#include "common/picojson.h"
-#include "common/platform_exception.h"
+#include <string>
 #include <vector>
-#include <runtime_info.h>
+
 #include <radio.h>
+#include <runtime_info.h>
+
+#include "common/picojson.h"
+#include "common/platform_exception.h"
 
 #include "radio_instance.h"
 
@@ -20,52 +21,36 @@ namespace extension {
 namespace radio {
 
 class FMRadioManager {
-public:
-
-    static FMRadioManager* GetInstance(bool safe  = true);
-
-    radio_h * GetRadioInstance();
-    std::vector<double> * GetFreqs();
-
-    void Start(double freq);
-    void Stop();
-    void SeekUp(const picojson::value& args);
-    void SeekDown(const picojson::value& args);
-    void ScanStart(const picojson::value& args);
-    void ScanStop(const picojson::value& args);
-    void SetFMRadioInterruptedListener();
-    void UnsetFMRadioInterruptedListener();
-    void SetAntennaChangeListener();
-    void UnsetAntennaChangeListener();
-
-    bool MuteGetter();
-    void MuteSetter(const picojson::value& args);
-    double FrequencyGetter();
-    double SignalStrengthGetter();
-    bool AntennaGetter();
-    char* StateGetter();
-
-private:
-    std::vector<double> 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);
-    static void ScanStartCB(int frequency, void *user_data);
-    static void ScanStopCB(void *user_data);
-    static void ScanCompleteCB(void *user_data);
-    int Create();
-    FMRadioManager();
-    ~FMRadioManager();
-
+ public:
+  static FMRadioManager* GetInstance();
+
+  void Start(double freq);
+  void Stop();
+  void SeekUp(double callback_id);
+  void SeekDown(double callback_id);
+  void ScanStart(double callback_id);
+  void ScanStop(double callback_id);
+  void SetFMRadioInterruptedListener();
+  void UnsetFMRadioInterruptedListener();
+  void SetAntennaChangeListener();
+  void UnsetAntennaChangeListener();
+
+  bool IsMuted();
+  void SetMute(bool mute);
+  void SetFrequency(double frequency);
+  double GetFrequency();
+  double GetSignalStrength();
+  bool HasAntenna();
+  const char* GetState();
+
+ private:
+  FMRadioManager();
+  ~FMRadioManager();
+
+  radio_h radio_instance_;
 };
 
-} // namespace
+} // namespace radio
 } // namespace extension
 
 #endif // RADIO_RADIO_MANAGER_H_
-