Remove Tizen API from the plugin class

Author: HakkyuKim

packages/audioplayers/tizen/src/audio_player.cc

@@ -60,7 +60,7 @@ void AudioPlayer::Play() {
       ret = player_start(player_);
       HandleResult("player_start", ret);
       should_play_ = false;
-      start_playing_listener_(player_id_);
+      EmitPositionUpdates();
       break;
     default:
       // "player is already playing audio.
@@ -98,6 +98,10 @@ void AudioPlayer::Release() {
     player_destroy(player_);
     player_ = nullptr;
   }
+  if (timer_) {
+    ecore_timer_del(timer_);
+    timer_ = nullptr;
+  }
 }
 
 void AudioPlayer::Seek(int position) {
@@ -236,6 +240,10 @@ void AudioPlayer::PreparePlayer() {
   seeking_ = false;
 }
 
+void AudioPlayer::EmitPositionUpdates() {
+  ecore_main_loop_thread_safe_call_async(StartPositionUpdates, (void *)this);
+}
+
 void AudioPlayer::ResetPlayer() {
   int ret;
   player_state_e state = GetPlayerState();
@@ -287,7 +295,7 @@ void AudioPlayer::OnPrepared(void *data) {
   if (player->should_play_) {
     ret = player_start(player->player_);
     if (ret == PLAYER_ERROR_NONE) {
-      player->start_playing_listener_(player->player_id_);
+      player->EmitPositionUpdates();
     }
     player->should_play_ = false;
   }
@@ -330,3 +338,31 @@ void AudioPlayer::OnErrorOccurred(int code, void *data) {
   AudioPlayer *player = (AudioPlayer *)data;
   player->error_listener_(player->player_id_, "error occurred: " + error);
 }
+
+void AudioPlayer::StartPositionUpdates(void *data) {
+  AudioPlayer *player = (AudioPlayer *)data;
+  if (!player->timer_) {
+    const double kTimeInterval = 0.2;
+    player->timer_ = ecore_timer_add(kTimeInterval, OnPositionUpdate, data);
+    if (player->timer_ == nullptr) {
+      LOG_ERROR("failed to add timer for UpdatePosition");
+    }
+  }
+}
+
+Eina_Bool AudioPlayer::OnPositionUpdate(void *data) {
+  AudioPlayer *player = (AudioPlayer *)data;
+  std::string player_id = player->GetPlayerId();
+  try {
+    if (player->IsPlaying()) {
+      int duration = player->GetDuration();
+      int position = player->GetCurrentPosition();
+      player->start_playing_listener_(player_id, duration, position);
+      return ECORE_CALLBACK_RENEW;
+    }
+  } catch (...) {
+    LOG_ERROR("failed to update position for player %s", player_id.c_str());
+  }
+  player->timer_ = nullptr;
+  return ECORE_CALLBACK_CANCEL;
+}

packages/audioplayers/tizen/src/audio_player.h

@@ -1,6 +1,7 @@
 #ifndef AUDIO_PLAYER_H_
 #define AUDIO_PLAYER_H_
 
+#include <Ecore.h>
 #include <player.h>
 
 #include <functional>
@@ -11,7 +12,8 @@ enum class ReleaseMode { kRelease, kLoop, kStop };
 
 using PreparedListener =
     std::function<void(const std::string &player_id, int duration)>;
-using StartPlayingListener = std::function<void(const std::string &player_id)>;
+using StartPlayingListener = std::function<void(
+    const std::string &player_id, const int duration, const int position)>;
 using SeekCompletedListener = std::function<void(const std::string &player_id)>;
 using PlayCompletedListener = std::function<void(const std::string &player_id)>;
 using ErrorListener = std::function<void(const std::string &player_id,
@@ -51,13 +53,16 @@ class AudioPlayer {
   // The player state should be idle before calling this function.
   void PreparePlayer();
   void ResetPlayer();
+  void EmitPositionUpdates();
   player_state_e GetPlayerState();
 
   static void OnPrepared(void *data);
   static void OnSeekCompleted(void *data);
   static void OnPlayCompleted(void *data);
   static void OnInterrupted(player_interrupted_code_e code, void *data);
   static void OnErrorOccurred(int code, void *data);
+  static void StartPositionUpdates(void *data);
+  static Eina_Bool OnPositionUpdate(void *data);
 
   player_h player_ = nullptr;
   std::string player_id_;
@@ -71,6 +76,7 @@ class AudioPlayer {
   bool preparing_ = false;
   bool seeking_ = false;
   bool should_play_ = false;
+  Ecore_Timer *timer_ = nullptr;
   PreparedListener prepared_listener_;
   StartPlayingListener start_playing_listener_;
   SeekCompletedListener seek_completed_listener_;

packages/audioplayers/tizen/src/audioplayers_tizen_plugin.cc

@@ -1,6 +1,5 @@
 #include "audioplayers_tizen_plugin.h"
 
-#include <Ecore.h>
 #include <flutter/encodable_value.h>
 #include <flutter/method_channel.h>
 #include <flutter/plugin_registrar.h>
@@ -15,8 +14,6 @@
 
 namespace {
 
-const double kTimeInterval = 0.2;
-
 template <typename T>
 static bool GetValueFromEncodableMap(const flutter::EncodableMap *map,
                                      const char *key, T &out) {
@@ -51,12 +48,7 @@ class AudioplayersTizenPlugin : public flutter::Plugin {
 
   AudioplayersTizenPlugin() {}
 
-  virtual ~AudioplayersTizenPlugin() {
-    if (timer_) {
-      ecore_timer_del(timer_);
-      timer_ = nullptr;
-    }
-  }
+  virtual ~AudioplayersTizenPlugin() {}
 
  private:
   void HandleMethodCall(
@@ -208,9 +200,25 @@ class AudioplayersTizenPlugin : public flutter::Plugin {
         };
 
     StartPlayingListener start_playing_listener =
-        [plugin = this](const std::string &player_id) {
-          ecore_main_loop_thread_safe_call_async(StartPositionUpdates,
-                                                 (void *)plugin);
+        [channel = channel_.get()](const std::string &player_id,
+                                   const int duration, const int position) {
+          flutter::EncodableMap durationWrapped = {
+              {flutter::EncodableValue("playerId"),
+               flutter::EncodableValue(player_id)},
+              {flutter::EncodableValue("value"),
+               flutter::EncodableValue(duration)}};
+          channel->InvokeMethod(
+              "audio.onDuration",
+              std::make_unique<flutter::EncodableValue>(durationWrapped));
+
+          flutter::EncodableMap positionWrapped = {
+              {flutter::EncodableValue("playerId"),
+               flutter::EncodableValue(player_id)},
+              {flutter::EncodableValue("value"),
+               flutter::EncodableValue(position)}};
+          channel->InvokeMethod(
+              "audio.onCurrentPosition",
+              std::make_unique<flutter::EncodableValue>(positionWrapped));
         };
 
     PlayCompletedListener play_completed_listener =
@@ -242,59 +250,6 @@ class AudioplayersTizenPlugin : public flutter::Plugin {
     return audio_players_[player_id].get();
   }
 
-  static void StartPositionUpdates(void *data) {
-    AudioplayersTizenPlugin *plugin = (AudioplayersTizenPlugin *)data;
-    if (!plugin->timer_) {
-      plugin->timer_ = ecore_timer_add(kTimeInterval, UpdatePosition, data);
-      if (plugin->timer_ == nullptr) {
-        LOG_ERROR("failed to add timer for UpdatePosition");
-      }
-    }
-  }
-
-  static Eina_Bool UpdatePosition(void *data) {
-    AudioplayersTizenPlugin *plugin = (AudioplayersTizenPlugin *)data;
-    bool none_playing = true;
-    auto iter = plugin->audio_players_.begin();
-    while (iter != plugin->audio_players_.end()) {
-      try {
-        std::string player_id = iter->second->GetPlayerId();
-        if (iter->second->IsPlaying()) {
-          none_playing = false;
-          flutter::EncodableMap duration = {
-              {flutter::EncodableValue("playerId"),
-               flutter::EncodableValue(player_id)},
-              {flutter::EncodableValue("value"),
-               flutter::EncodableValue(iter->second->GetDuration())}};
-          plugin->channel_->InvokeMethod(
-              "audio.onDuration",
-              std::make_unique<flutter::EncodableValue>(duration));
-
-          flutter::EncodableMap position = {
-              {flutter::EncodableValue("playerId"),
-               flutter::EncodableValue(player_id)},
-              {flutter::EncodableValue("value"),
-               flutter::EncodableValue(iter->second->GetCurrentPosition())}};
-          plugin->channel_->InvokeMethod(
-              "audio.onCurrentPosition",
-              std::make_unique<flutter::EncodableValue>(position));
-        }
-        iter++;
-      } catch (...) {
-        LOG_ERROR("failed to update position for player %s",
-                  iter->second->GetPlayerId().c_str());
-      }
-    }
-
-    if (none_playing) {
-      plugin->timer_ = nullptr;
-      return ECORE_CALLBACK_CANCEL;
-    } else {
-      return ECORE_CALLBACK_RENEW;
-    }
-  }
-
-  Ecore_Timer *timer_ = nullptr;
   std::unique_ptr<flutter::MethodChannel<flutter::EncodableValue>> channel_;
   std::map<std::string, std::unique_ptr<AudioPlayer>> audio_players_;
 };