review.tizen.org Git - platform/framework/web/crosswalk-tizen.git/blob

   1 // Copyright 2017 Samsung Electronics Inc. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_BASE_TIZEN_SUSPENDING_MEDIA_PLAYER_H_
   6 #define MEDIA_BASE_TIZEN_SUSPENDING_MEDIA_PLAYER_H_
   7
   8 #include <queue>
   9 #include <utility>
  10
  11 #include "base/memory/ptr_util.h"
  12 #include "base/threading/thread_task_runner_handle.h"
  13 #include "media/base/timestamp_constants.h"
  14 #include "media/base/tizen/demuxer_efl.h"
  15 #include "media/base/tizen/media_player_efl.h"
  16 #include "media/base/tizen/media_player_interface_efl.h"
  17 #include "media/base/tizen/media_player_manager_efl.h"
  18
  19 namespace media {
  20
  21 class SuspendingMediaPlayer;
  22
  23 class SuspendingMediaSourcePlayer : public DemuxerEflClient, public DemuxerEfl {
  24  public:
  25   SuspendingMediaSourcePlayer(SuspendingMediaPlayer* parent,
  26                               std::unique_ptr<DemuxerEfl> demuxer)
  27       : parent_(parent),
  28         demuxer_client_(nullptr),
  29         demuxer_(std::move(demuxer)) {}
  30
  31   // DemuxerEflClient interface
  32   void OnDemuxerConfigsAvailable(const DemuxerConfigs& params) override;
  33   void OnDemuxerDataAvailable(base::SharedMemoryHandle foreign_memory_handle,
  34                               const DemuxedBufferMetaData& meta_data) override;
  35   void OnDemuxerSeekDone(
  36       const base::TimeDelta& actual_browser_seek_time) override;
  37   void OnDemuxerDurationChanged(base::TimeDelta duration) override;
  38 #if defined(OS_TIZEN_TV_PRODUCT)
  39   void OnDemuxerStateChanged(const DemuxerConfigs& params) override;
  40 #endif
  41
  42   // DemuxerEfl interface
  43   void Initialize(DemuxerEflClient* client) override;
  44   void RequestDemuxerSeek(const base::TimeDelta& time_to_seek) override;
  45   void RequestDemuxerData(DemuxerStream::Type type) override;
  46
  47  private:
  48   SuspendingMediaPlayer* const parent_;
  49   DemuxerEflClient* demuxer_client_;
  50   const std::unique_ptr<DemuxerEfl> demuxer_;
  51 };
  52
  53 class SuspendingMediaPlayer : public MediaPlayerInterfaceEfl,
  54                               public MediaPlayerManager {
  55   struct constructor_tag {};
  56
  57  public:
  58   static MediaPlayerInterfaceEfl* CreatePlayer(int player_id,
  59                                                const GURL& url,
  60                                                const std::string& mime_type,
  61                                                MediaPlayerManager* manager,
  62                                                const std::string& user_agent,
  63                                                int audio_latency_mode,
  64                                                bool video_hole) {
  65     auto suspending_player =
  66         base::MakeUnique<SuspendingMediaPlayer>(constructor_tag());
  67     suspending_player->InjectMediaPlayer(MediaPlayerEfl::CreatePlayer(
  68         player_id, url, mime_type, suspending_player->InjectManager(manager),
  69         user_agent, audio_latency_mode, video_hole));
  70     return suspending_player.release();
  71   }
  72
  73   static MediaPlayerInterfaceEfl* CreatePlayer(
  74       int player_id,
  75       std::unique_ptr<DemuxerEfl> demuxer,
  76       MediaPlayerManager* manager,
  77       bool video_hole) {
  78     auto suspending_player =
  79         base::MakeUnique<SuspendingMediaPlayer>(constructor_tag());
  80     suspending_player->InjectMediaPlayer(MediaPlayerEfl::CreatePlayer(
  81         player_id, suspending_player->InjectDemuxer(std::move(demuxer)),
  82         suspending_player->InjectManager(manager), video_hole));
  83     return suspending_player.release();
  84   }
  85
  86   explicit SuspendingMediaPlayer(constructor_tag) : SuspendingMediaPlayer() {}
  87
  88   // MediaPlayerEfl interface
  89   int GetPlayerId() const override;
  90   void Initialize() override;
  91   void Play() override;
  92   void Pause(bool is_media_related_action) override;
  93   void SetRate(double rate) override;
  94   void Seek(base::TimeDelta time) override;
  95   void SetVolume(double volume) override;
  96   base::TimeDelta GetCurrentTime() override;
  97   void EnteredFullscreen() override;
  98   void ExitedFullscreen() override;
  99
 100 #if defined(TIZEN_SOUND_FOCUS)
 101   // SoundFocusClient interface
 102   void SetResumePlayingBySFM(bool resume_playing) override;
 103   void OnFocusAcquired() override;
 104   void OnFocusReleased(bool resume_playing) override;
 105 #endif
 106
 107 #if defined(TIZEN_EXTERNAL_MEDIA_EVENT)
 108   void ReleaseKeyGrab(int player_id) override;
 109   void AcquireKeyGrab(int player_id) override;
 110 #endif
 111
 112   // Interface for resource handling
 113   MediaTypeFlags GetMediaType() const override;
 114   bool IsPlayerSuspended() const;
 115   bool IsPlayerFullyResumed() const;
 116   bool IsPlayerResuming() const;
 117   void Suspend() override;
 118   void Resume() override;
 119
 120   double GetStartDate() override;
 121
 122 #if defined(TIZEN_VIDEO_HOLE)
 123   void SetGeometry(const gfx::RectF&) override;
 124   void OnWebViewMoved() override;
 125 #endif
 126
 127 #if defined(TIZEN_MULTIMEDIA_SUPPORT)
 128   void LaunchSystemVolumeController() override;
 129 #endif
 130
 131   // MediaPlayerManager interface
 132   MediaPlayerInterfaceEfl* GetPlayer(int player_id) override;
 133   void OnTimeChanged(int player_id) override;
 134   void OnTimeUpdate(int player_id, base::TimeDelta current_time) override;
 135   void OnRequestSeek(int player_id, base::TimeDelta seek_time) override;
 136   void OnPauseStateChange(int player_id, bool state) override;
 137   void OnSeekComplete(int player_id) override;
 138   void OnBufferUpdate(int player_id, int buffering_percentage) override;
 139   void OnDurationChange(int player_id, base::TimeDelta duration) override;
 140   void OnReadyStateChange(int player_id,
 141                           blink::WebMediaPlayer::ReadyState state) override;
 142   void OnNetworkStateChange(int player_id,
 143                             blink::WebMediaPlayer::NetworkState state) override;
 144   void OnMediaDataChange(int player_id,
 145                          int width,
 146                          int height,
 147                          int media) override;
 148   void OnNewFrameAvailable(int player_id,
 149                            base::SharedMemoryHandle handle,
 150                            uint32_t length,
 151                            base::TimeDelta timestamp) override;
 152   void OnInitComplete(int player_id, bool success) override;
 153   void OnResumeComplete(int player_id) override;
 154   void OnSuspendComplete(int player_id) override;
 155
 156 #if defined(TIZEN_VIDEO_HOLE)
 157   gfx::Rect GetViewportRect() const override;
 158 #endif
 159
 160 #if defined(TIZEN_TBM_SUPPORT)
 161   void OnNewTbmBufferAvailable(int player_id,
 162                                gfx::TbmBufferHandle tbm_handle,
 163                                base::TimeDelta timestamp) override;
 164 #endif
 165
 166 #if defined(OS_TIZEN_TV_PRODUCT)
 167   void OnAddAudioTrack(int player_id,
 168                        const std::string& kind,
 169                        const std::string& language,
 170                        const std::string& id,
 171                        bool selected) override;
 172   void OnAddVideoTrack(int player_id,
 173                        const std::string& kind,
 174                        const std::string& language,
 175                        const std::string& id,
 176                        bool selected) override;
 177   void OnAddTextTrack(int player_id,
 178                       const std::string& label,
 179                       const std::string& language,
 180                       const std::string& id) override;
 181
 182   void OnSeekableTimeChange(int player_id,
 183                             base::TimeDelta min_time,
 184                             base::TimeDelta max_time) override;
 185
 186   void OnInbandEventTextTrack(int player_id, const std::string& info) override;
 187   void OnInbandEventTextCue(int player_id,
 188                             const std::string& info,
 189                             unsigned int id,
 190                             long long int start_time,
 191                             long long int end_time) override;
 192
 193   void OnDrmError(int player_id) override;
 194 #endif
 195
 196   void StorePosition(const base::TimeDelta& position);
 197
 198   content::WebContents* GetWebContents(int player_id) override;
 199
 200   bool IsPaused() const override { return player_->IsPaused(); }
 201
 202   void OnPlayerSuspendRequest(int player_id) override;
 203
 204   bool ShouldSeekAfterResume() const override {
 205     return player_->ShouldSeekAfterResume();
 206   }
 207
 208   bool HasConfigs() const override { return player_->HasConfigs(); }
 209
 210 #if defined(TIZEN_MULTIMEDIA_SUPPORT)
 211   void OnSystemVolumeChange(int player_id, int volume) override;
 212 #endif
 213
 214  private:
 215   SuspendingMediaPlayer()
 216       : task_runner_(base::ThreadTaskRunnerHandle::Get()),
 217         weak_factory_(this) {}
 218
 219   enum class player_state {
 220     RESUMED,
 221     SUSPENDING,
 222     SUSPENDED,
 223     RESUMING,
 224   };
 225
 226   enum class action_after_resume { NONE, PLAY, PAUSE };
 227
 228   enum class seek_state { SEEK_NONE, SEEK_ON_DEMUXER, SEEK_ON_PLAYER };
 229
 230   MediaPlayerManager* InjectManager(MediaPlayerManager* manager) {
 231     manager_ = manager;
 232     return this;
 233   }
 234
 235   // Must take ownership
 236   MediaPlayerInterfaceEfl* InjectMediaPlayer(MediaPlayerInterfaceEfl* player) {
 237     player_ = std::unique_ptr<MediaPlayerInterfaceEfl>(player);
 238     return this;
 239   }
 240
 241   std::unique_ptr<DemuxerEfl> InjectDemuxer(
 242       std::unique_ptr<DemuxerEfl> demuxer) {
 243     return base::MakeUnique<SuspendingMediaSourcePlayer>(this,
 244                                                          std::move(demuxer));
 245   }
 246
 247   void AddFunctionToQueue(std::function<void()> function);
 248   void ExecuteFunction(const std::function<void()>& function);
 249   void ExecuteQueuedFunctionsAfterResume();
 250
 251   std::unique_ptr<MediaPlayerInterfaceEfl> player_;
 252   MediaPlayerManager* manager_ = nullptr;
 253
 254   player_state state_{player_state::RESUMED};
 255   seek_state seek_state_{seek_state::SEEK_NONE};
 256   bool is_paused_{false};
 257   bool is_seek_after_resume_{false};
 258   base::TimeDelta stored_position_;
 259   action_after_resume action_after_resume_{action_after_resume::NONE};
 260
 261   std::queue<std::function<void()>> functions_to_be_called_after_resume_;
 262
 263   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 264   base::WeakPtrFactory<SuspendingMediaPlayer> weak_factory_;
 265
 266   friend class SuspendingMediaSourcePlayer;
 267
 268   DISALLOW_COPY_AND_ASSIGN(SuspendingMediaPlayer);
 269 };
 270
 271 }  // namespace media
 272
 273 #endif  // MEDIA_BASE_TIZEN_SUSPENDING_MEDIA_PLAYER_H_