[FMRadio] Allow to create multiple instances of RadioInstance class.

Change-Id: I2afba9bbc266d942da7c1f5a8f7f26f7ad70ccf5

diff --git a/src/radio/radio_extension.cc b/src/radio/radio_extension.cc
index 664873e..bd4ae06 100644 (file)
--- a/src/radio/radio_extension.cc
+++ b/src/radio/radio_extension.cc
@@ -24,5 +24,5 @@ RadioExtension::~RadioExtension() {
 }
 
 common::Instance* RadioExtension::CreateInstance() {
-  return &extension::radio::RadioInstance::getInstance();
+  return new extension::radio::RadioInstance();
 }

diff --git a/src/radio/radio_instance.cc b/src/radio/radio_instance.cc
index cd282e6..6fd237c 100644 (file)
--- a/src/radio/radio_instance.cc
+++ b/src/radio/radio_instance.cc
@@ -10,15 +10,14 @@
 
 #include "common/logger.h"
 
-#include "radio/radio_manager.h"
-
 namespace extension {
 namespace radio {
 
 using namespace common;
 using namespace extension::radio;
 
-RadioInstance::RadioInstance() {
+RadioInstance::RadioInstance()
+    : manager_(*this) {
   using std::placeholders::_1;
   using std::placeholders::_2;
 
@@ -52,69 +51,60 @@ RadioInstance::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);
+  ReportSuccess(picojson::value(manager_.IsMuted()), out);
 }
 
 void RadioInstance::MuteSetter(const picojson::value& args,
                                picojson::object& out) {
   LoggerD("Enter");
-  FMRadioManager::GetInstance()->SetMute(args.get("mute").get<bool>());
+  manager_.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);
+  ReportSuccess(picojson::value(manager_.HasAntenna()), out);
 }
 
 void RadioInstance::StateGetter(const picojson::value& args,
                                 picojson::object& out) {
   LoggerD("Enter");
-  ReportSuccess(picojson::value(FMRadioManager::GetInstance()->GetState()),
-                out);
+  ReportSuccess(picojson::value(manager_.GetState()), out);
 }
 
 void RadioInstance::FrequencyGetter(const picojson::value& args,
                                     picojson::object& out) {
   LoggerD("Enter");
-  ReportSuccess(picojson::value(FMRadioManager::GetInstance()->GetFrequency()),
-                out);
+  ReportSuccess(picojson::value(manager_.GetFrequency()), out);
 }
 
 void RadioInstance::SignalStrengthGetter(const picojson::value& args,
                                          picojson::object& out) {
   LoggerD("Enter");
-  ReportSuccess(picojson::value(FMRadioManager::GetInstance()->GetSignalStrength()),
-                out);
+  ReportSuccess(picojson::value(manager_.GetSignalStrength()), out);
 }
 
 void RadioInstance::SeekUp(const picojson::value& args, picojson::object& out) {
   LoggerD("Enter");
-  FMRadioManager::GetInstance()->SeekUp(args.get("callbackId").get<double>());
+  manager_.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>());
+  manager_.SeekDown(args.get("callbackId").get<double>());
   ReportSuccess(out);
 }
 
 void RadioInstance::Start(const picojson::value& args, picojson::object& out) {
   LoggerD("Enter");
 
-  PlatformResult result = FMRadioManager::GetInstance()->Start(args.get("frequency").get<double>());
+  PlatformResult result = manager_.Start(args.get("frequency").get<double>());
 
   if (result) {
     ReportSuccess(out);
@@ -126,7 +116,7 @@ void RadioInstance::Start(const picojson::value& args, picojson::object& out) {
 void RadioInstance::Stop(const picojson::value& args, picojson::object& out) {
   LoggerD("Enter");
 
-  PlatformResult result = FMRadioManager::GetInstance()->Stop();
+  PlatformResult result = manager_.Stop();
 
   if (result) {
     ReportSuccess(out);
@@ -138,14 +128,14 @@ void RadioInstance::Stop(const picojson::value& args, picojson::object& out) {
 void RadioInstance::ScanStart(const picojson::value& args,
                               picojson::object& out) {
   LoggerD("Enter");
-  FMRadioManager::GetInstance()->ScanStart(args.get("callbackId").get<double>());
+  manager_.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>());
+  manager_.ScanStop(args.get("callbackId").get<double>());
   ReportSuccess(out);
 }
 
@@ -153,7 +143,7 @@ void RadioInstance::SetFMRadioInterruptedListener(const picojson::value& args,
                                                   picojson::object& out) {
   LoggerD("Enter");
 
-  PlatformResult result = FMRadioManager::GetInstance()->SetFMRadioInterruptedListener();
+  PlatformResult result = manager_.SetFMRadioInterruptedListener();
 
   if (result) {
     ReportSuccess(out);
@@ -166,7 +156,7 @@ void RadioInstance::UnsetFMRadioInterruptedListener(const picojson::value& args,
                                                     picojson::object& out) {
   LoggerD("Enter");
 
-  PlatformResult result = FMRadioManager::GetInstance()->UnsetFMRadioInterruptedListener();
+  PlatformResult result = manager_.UnsetFMRadioInterruptedListener();
 
   if (result) {
     ReportSuccess(out);
@@ -179,7 +169,7 @@ void RadioInstance::SetAntennaChangeListener(const picojson::value& args,
                                              picojson::object& out) {
   LoggerD("Enter");
 
-  PlatformResult result = FMRadioManager::GetInstance()->SetAntennaChangeListener();
+  PlatformResult result = manager_.SetAntennaChangeListener();
 
   if (result) {
     ReportSuccess(out);
@@ -192,7 +182,7 @@ void RadioInstance::UnsetAntennaChangeListener(const picojson::value& args,
                                                picojson::object& out) {
   LoggerD("Enter");
 
-  PlatformResult result = FMRadioManager::GetInstance()->UnsetAntennaChangeListener();
+  PlatformResult result = manager_.UnsetAntennaChangeListener();
 
   if (result) {
     ReportSuccess(out);

diff --git a/src/radio/radio_instance.h b/src/radio/radio_instance.h
index 448f11c..cf686e3 100644 (file)
--- a/src/radio/radio_instance.h
+++ b/src/radio/radio_instance.h
@@ -8,6 +8,8 @@
 #include "common/extension.h"
 #include "common/picojson.h"
 
+#include "radio/radio_manager.h"
+
 namespace extension {
 namespace radio {
 
@@ -16,8 +18,6 @@ class RadioInstance : public common::ParsedInstance {
   RadioInstance();
   virtual ~RadioInstance();
 
-  static RadioInstance& getInstance();
-
  private:
   void MuteGetter(const picojson::value& args, picojson::object& out);
   void MuteSetter(const picojson::value& args, picojson::object& out);
@@ -35,6 +35,8 @@ class RadioInstance : public common::ParsedInstance {
   void UnsetFMRadioInterruptedListener(const picojson::value& args, picojson::object& out);
   void SetAntennaChangeListener(const picojson::value& args, picojson::object& out);
   void UnsetAntennaChangeListener(const picojson::value& args, picojson::object& out);
+
+  FMRadioManager manager_;
 };
 
 } // namespace radio

diff --git a/src/radio/radio_manager.cc b/src/radio/radio_manager.cc
index 1e3e08a..aca429e 100755 (executable)
--- a/src/radio/radio_manager.cc
+++ b/src/radio/radio_manager.cc
@@ -14,6 +14,8 @@
 #include "common/logger.h"
 #include "common/extension.h"
 
+#include "radio/radio_instance.h"
+
 using namespace common;
 using namespace std;
 
@@ -34,31 +36,6 @@ static void AddCallbackID(double callbackId, picojson::object* obj) {
   obj->insert(std::make_pair("callbackId", picojson::value(callbackId)));
 }
 
-static void PostResultSuccess(double callbackId, picojson::value* event) {
-  auto& obj = event->get<picojson::object>();
-
-  tools::ReportSuccess(obj);
-  AddCallbackID(callbackId, &obj);
-
-  RadioInstance::getInstance().PostMessage(event->serialize().c_str());
-}
-
-static void PostResultSuccess(double callbackId) {
-  picojson::value event{picojson::object()};
-
-  PostResultSuccess(callbackId, &event);
-}
-
-static void PostResultFailure(double callbackId, const PlatformResult& result) {
-  picojson::value event{picojson::object()};
-  auto& obj = event.get<picojson::object>();
-
-  tools::ReportError(result, &obj);
-  AddCallbackID(callbackId, &obj);
-
-  RadioInstance::getInstance().PostMessage(event.serialize().c_str());
-}
-
 PlatformResult GetPlatformResult(const std::string& str, int err) {
   LoggerD("Enter");
 
@@ -116,43 +93,53 @@ double ToMHz(int frequency) {
   return static_cast<double>(frequency) / 1000.0;
 }
 
+struct RadioData {
+  explicit RadioData(FMRadioManager& manager)
+      : manager_(manager),
+        callback_id_(0.0) {
+  }
+
+  FMRadioManager& manager_;
+  double callback_id_;
+};
+
+struct RadioScanData : public RadioData {
+  using RadioData::RadioData;
+  std::vector<int> frequencies_;
+};
+
 void RadioSeekCallback(int frequency, void* user_data) {
   LoggerD("Enter");
 
-  double* id = static_cast<double*>(user_data);
+  RadioData* data = static_cast<RadioData*>(user_data);
+  PlatformResult result = data->manager_.SetFrequency(ToMHz(frequency));
 
-  PlatformResult result = FMRadioManager::GetInstance()->SetFrequency(ToMHz(frequency));
   if (result) {
-    PostResultSuccess(*id);
+    data->manager_.PostResultSuccess(data->callback_id_);
   } else {
-    PostResultFailure(*id, result);
+    data->manager_.PostResultFailure(data->callback_id_, result);
   }
 
-  delete id;
+  delete data;
 }
 
-struct ScanData {
-  double callback_id_;
-  std::vector<int> frequencies_;
-};
-
 void ScanStartCallback(int frequency, void* user_data) {
   LoggerD("Enter");
 
-  ScanData* data = static_cast<ScanData*>(user_data);
+  RadioScanData* data = static_cast<RadioScanData*>(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", picojson::value("FMRadio_Onfrequencyfound")));
-  RadioInstance::getInstance().PostMessage(event.serialize().c_str());
+  data->manager_.PostMessage(event.serialize());
 }
 
 void ScanCompleteCallback(void* user_data) {
   LoggerD("Enter");
 
-  ScanData* data = static_cast<ScanData*>(user_data);
+  RadioScanData* data = static_cast<RadioScanData*>(user_data);
 
   picojson::value event{picojson::object()};
   auto& obj = event.get<picojson::object>();
@@ -164,17 +151,17 @@ void ScanCompleteCallback(void* user_data) {
   }
 
   obj.insert(std::make_pair("frequencies", picojson::value(frequencies)));
-  PostResultSuccess(data->callback_id_, &event);
+  data->manager_.PostResultSuccess(data->callback_id_, &event);
 
   delete data;
 }
 
 void ScanStopCallback(void *user_data) {
   LoggerD("Enter");
-  double* callback_id = static_cast<double*>(user_data);
+  RadioData* data = static_cast<RadioData*>(user_data);
 
-  PostResultSuccess(*callback_id);
-  delete callback_id;
+  data->manager_.PostResultSuccess(data->callback_id_);
+  delete data;
 }
 
 void RadioInterruptedCallback(radio_interrupted_code_e code, void *user_data) {
@@ -193,7 +180,8 @@ void RadioInterruptedCallback(radio_interrupted_code_e code, void *user_data) {
     obj.insert(std::make_pair("reason", picojson::value(TranslateInterruptedCode(code))));
   }
 
-  RadioInstance::getInstance().PostMessage(event.serialize().c_str());
+  FMRadioManager* manager = static_cast<FMRadioManager*>(user_data);
+  manager->PostMessage(event.serialize());
 }
 
 
@@ -212,7 +200,8 @@ void RadioAntennaCallback(runtime_info_key_e key, void* user_data) {
   obj.insert(std::make_pair("connected", picojson::value(connected)));
   obj.insert(std::make_pair("listenerId", picojson::value("FMRadio_Antenna")));
 
-  RadioInstance::getInstance().PostMessage(event.serialize().c_str());
+  FMRadioManager* manager = static_cast<FMRadioManager*>(user_data);
+  manager->PostMessage(event.serialize());
 }
 
 } // namespace
@@ -309,8 +298,9 @@ double FMRadioManager::GetSignalStrength() {
   }
 }
 
-FMRadioManager::FMRadioManager()
-    : radio_instance_(nullptr) {
+FMRadioManager::FMRadioManager(RadioInstance& instance)
+    : instance_(instance),
+      radio_instance_(nullptr) {
   LoggerD("Enter");
 
   const auto err = radio_create(&radio_instance_);
@@ -335,13 +325,6 @@ FMRadioManager::~FMRadioManager() {
   }
 }
 
-FMRadioManager* FMRadioManager::GetInstance() {
-  LoggerD("Enter");
-
-  static FMRadioManager instance;
-  return &instance;
-}
-
 PlatformResult FMRadioManager::Start(double frequency) {
   LoggerD("Enter, frequency: %f", frequency);
 
@@ -363,7 +346,8 @@ PlatformResult FMRadioManager::Stop() {
 void FMRadioManager::SeekUp(double callback_id) {
   LoggerD("Enter");
 
-  double* user_data = new double(callback_id);
+  RadioData* user_data = new RadioData(*this);
+  user_data->callback_id_ = callback_id;
 
   const auto err = radio_seek_up(radio_instance_, RadioSeekCallback, user_data);
 
@@ -376,7 +360,8 @@ void FMRadioManager::SeekUp(double callback_id) {
 void FMRadioManager::SeekDown(double callback_id) {
   LoggerD("Enter");
 
-  double* user_data = new double(callback_id);
+  RadioData* user_data = new RadioData(*this);
+  user_data->callback_id_ = callback_id;
 
   const auto err = radio_seek_down(radio_instance_, RadioSeekCallback, user_data);
 
@@ -389,7 +374,7 @@ void FMRadioManager::SeekDown(double callback_id) {
 void FMRadioManager::ScanStart(double callback_id) {
   LoggerD("Enter");
 
-  ScanData* user_data = new ScanData();
+  RadioScanData* user_data = new RadioScanData(*this);
   user_data->callback_id_ = callback_id;
 
   auto err = radio_set_scan_completed_cb(radio_instance_, ScanCompleteCallback,
@@ -412,7 +397,8 @@ void FMRadioManager::ScanStart(double callback_id) {
 void FMRadioManager::ScanStop(double callback_id) {
   LoggerD("Enter");
 
-  double* user_data = new double(callback_id);
+  RadioScanData* user_data = new RadioScanData(*this);
+  user_data->callback_id_ = callback_id;
 
   auto err = radio_unset_scan_completed_cb(radio_instance_);
   if (RADIO_ERROR_NONE != err) {
@@ -434,7 +420,7 @@ common::PlatformResult FMRadioManager::SetFMRadioInterruptedListener() {
 
   const auto err = radio_set_interrupted_cb(radio_instance_,
                                             RadioInterruptedCallback,
-                                            nullptr);
+                                            this);
   return CheckError("radio_set_interrupted_cb", err);
 }
 
@@ -451,7 +437,7 @@ common::PlatformResult FMRadioManager::SetAntennaChangeListener() {
   const auto err = runtime_info_set_changed_cb(
                             RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED,
                             RadioAntennaCallback,
-                            nullptr);
+                            this);
   return CheckError("runtime_info_set_changed_cb", err);
 }
 
@@ -462,6 +448,35 @@ common::PlatformResult FMRadioManager::UnsetAntennaChangeListener() {
   return CheckError("runtime_info_unset_changed_cb", err);
 }
 
+void FMRadioManager::PostMessage(const std::string& msg) const {
+  instance_.PostMessage(msg.c_str());
+}
+
+void FMRadioManager::PostResultSuccess(double callbackId, picojson::value* event) const {
+  auto& obj = event->get<picojson::object>();
+
+  tools::ReportSuccess(obj);
+  AddCallbackID(callbackId, &obj);
+
+  PostMessage(event->serialize());
+}
+
+void FMRadioManager::PostResultSuccess(double callbackId) const {
+  picojson::value event{picojson::object()};
+
+  PostResultSuccess(callbackId, &event);
+}
+
+void FMRadioManager::PostResultFailure(double callbackId, const PlatformResult& result) const {
+  picojson::value event{picojson::object()};
+  auto& obj = event.get<picojson::object>();
+
+  tools::ReportError(result, &obj);
+  AddCallbackID(callbackId, &obj);
+
+  PostMessage(event.serialize());
+}
+
 } // namespace radio
 } // namespace extension
 

diff --git a/src/radio/radio_manager.h b/src/radio/radio_manager.h
index 911a8c1..ecf1652 100755 (executable)
--- a/src/radio/radio_manager.h
+++ b/src/radio/radio_manager.h
@@ -15,14 +15,15 @@
 #include "common/picojson.h"
 #include "common/platform_result.h"
 
-#include "radio_instance.h"
-
 namespace extension {
 namespace radio {
 
+class RadioInstance;
+
 class FMRadioManager {
  public:
-  static FMRadioManager* GetInstance();
+  explicit FMRadioManager(RadioInstance& instance);
+  ~FMRadioManager();
 
   common::PlatformResult Start(double freq);
   common::PlatformResult Stop();
@@ -43,10 +44,13 @@ class FMRadioManager {
   bool HasAntenna();
   const char* GetState();
 
- private:
-  FMRadioManager();
-  ~FMRadioManager();
+  void PostMessage(const std::string& msg) const;
+  void PostResultSuccess(double callbackId, picojson::value* event) const;
+  void PostResultSuccess(double callbackId) const;
+  void PostResultFailure(double callbackId, const common::PlatformResult& result) const;
 
+ private:
+  RadioInstance& instance_;
   radio_h radio_instance_;
 };