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

   1 // Copyright 2014 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 CONTENT_BROWSER_MEDIA_TIZEN_BROWSER_MEDIA_PLAYER_MANAGER_EFL_H_
   6 #define CONTENT_BROWSER_MEDIA_TIZEN_BROWSER_MEDIA_PLAYER_MANAGER_EFL_H_
   7
   8 #include <unordered_map>
   9
  10 #include "base/containers/scoped_ptr_hash_map.h"
  11 #include "content/common/media/media_player_messages_enums_efl.h"
  12 #include "content/public/browser/browser_message_filter.h"
  13 #include "content/public/browser/render_frame_host.h"
  14 #include "content/public/browser/web_contents_observer.h"
  15 #include "media/base/tizen/media_player_interface_efl.h"
  16 #include "media/base/tizen/media_player_manager_efl.h"
  17 #include "media/base/tizen/media_capability_manager.h"
  18 #include "media/base/tizen/longest_conflict_strategy.h"
  19 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
  20
  21 #if defined(TIZEN_EXTERNAL_MEDIA_EVENT)
  22 #include "base/external_device/external_input_device_controller_tizen.h"
  23 #endif
  24
  25 #if defined(TIZEN_VIDEO_HOLE)
  26 namespace gfx {
  27 class Rect;
  28 class RectF;
  29 }
  30 #endif
  31
  32 namespace content {
  33
  34 // This class manages all the MediaPlayerEfl objects. It receives
  35 // control operations from the the render process, and forwards
  36 // them to corresponding MediaPlayerEfl object. Callbacks from
  37 // MediaPlayerEfl objects are converted to IPCs and then sent to the
  38 // render process.
  39 class CONTENT_EXPORT BrowserMediaPlayerManagerEfl
  40     : public media::MediaPlayerManager {
  41  public:
  42   // Returns a new instance using the registered factory if available.
  43   static BrowserMediaPlayerManagerEfl* GetInstance();
  44   ~BrowserMediaPlayerManagerEfl() override;
  45
  46   // media::MediaPlayerManager implementation.
  47   media::MediaPlayerInterfaceEfl* GetPlayer(int player_id) override;
  48   void OnTimeChanged(int player_id) override;
  49   void OnTimeUpdate(int player_id, base::TimeDelta current_time) override;
  50   void OnPauseStateChange(int player_id, bool state) override;
  51   void OnSeekComplete(int player_id) override;
  52   void OnRequestSeek(int player_id, base::TimeDelta seek_time) override;
  53   void OnBufferUpdate(int player_id, int percentage) override;
  54   void OnDurationChange(int player_id, base::TimeDelta duration) override;
  55   void OnReadyStateChange(int player_id,
  56                           blink::WebMediaPlayer::ReadyState state) override;
  57   void OnNetworkStateChange(int player_id,
  58                             blink::WebMediaPlayer::NetworkState state) override;
  59   void OnMediaDataChange(int player_id,
  60                          int width,
  61                          int height,
  62                          int media) override;
  63   void OnNewFrameAvailable(int player_id,
  64                            base::SharedMemoryHandle foreign_memory_handle,
  65                            uint32_t length,
  66                            base::TimeDelta timestamp) override;
  67
  68 #if defined(TIZEN_TBM_SUPPORT)
  69   void OnNewTbmBufferAvailable(int player_id,
  70                                gfx::TbmBufferHandle tbm_handle,
  71                                base::TimeDelta timestamp) override;
  72 #endif
  73
  74 #if defined(OS_TIZEN_TV_PRODUCT)
  75 #if defined(TIZEN_TBM_SUPPORT)
  76   void OnNotifyVideoTexturing(int player_id);
  77 #endif
  78   void OnAddAudioTrack(int player_id,
  79                        const std::string& kind,
  80                        const std::string& language,
  81                        const std::string& id,
  82                        bool selected) override;
  83   void OnAddVideoTrack(int player_id,
  84                        const std::string& kind,
  85                        const std::string& language,
  86                        const std::string& id,
  87                        bool selected) override;
  88   void OnAddTextTrack(int player_id,
  89                       const std::string& label,
  90                       const std::string& language,
  91                       const std::string& id) override;
  92   void OnSeekableTimeChange(int player_id,
  93                             base::TimeDelta min_time,
  94                             base::TimeDelta max_time) override;
  95   void OnDrmError(int player_id) override;
  96 #endif
  97
  98 #if defined(TIZEN_EXTERNAL_MEDIA_EVENT)
  99   void ReleaseKeyGrab(int player_id) override;
 100   void AcquireKeyGrab(int player_id) override;
 101 #endif
 102
 103   // Helper function to handle IPC from RenderMediaPlayerManagerEfl.
 104   void OnPlay(RenderFrameHost* render_frame_host, int player_id);
 105   void OnPause(RenderFrameHost* render_frame_host,
 106                int player_id,
 107                bool is_media_related_action);
 108   void OnSetVolume(RenderFrameHost* render_frame_host,
 109                    int player_id,
 110                    double volume);
 111   void OnSetRate(
 112       RenderFrameHost* render_frame_host, int player_id, double rate);
 113   void OnInitialize(RenderFrameHost* render_frame_host,
 114                     int player_id,
 115                     MediaPlayerHostMsg_Initialize_Type type,
 116                     const GURL& url,
 117                     const std::string& mime_type,
 118                     int demuxer_client_id);
 119   void OnDestroy(RenderFrameHost* render_frame_host, int player_id);
 120   void OnSeek(
 121       RenderFrameHost* render_frame_host, int player_id, base::TimeDelta time);
 122   void OnSuspend(RenderFrameHost* render_frame_host, int player_id);
 123   void OnResume(RenderFrameHost* render_frame_host,
 124                 int player_id,
 125                 bool is_last_played_player);
 126   void OnActivate(RenderFrameHost* render_frame_host, int player_id);
 127   void OnDeactivate(RenderFrameHost* render_frame_host, int player_id);
 128
 129 #if defined(TIZEN_MULTIMEDIA_SUPPORT)
 130   void OnLaunchSystemVolumeController(RenderFrameHost* render_frame_host,
 131                                       int player_id);
 132 #endif
 133
 134 #if defined(TIZEN_VIDEO_HOLE)
 135   gfx::Rect GetViewportRect() const override;
 136   void OnSetGeometry(int player_id, const gfx::RectF& rect);
 137   void OnWebViewMoved();
 138 #endif
 139
 140 #if defined(OS_TIZEN_TV_PRODUCT)
 141   void OnInbandEventTextTrack(int player_id, const std::string& info) override;
 142   void OnInbandEventTextCue(int player_id,
 143                             const std::string& info,
 144                             unsigned int id,
 145                             long long int start_time,
 146                             long long int end_time) override;
 147
 148   // Notify the playing video dimension for floating Video feature
 149   void NotifyPlayingVideoRect(int player_id, const gfx::RectF& rect);
 150 #endif
 151
 152   void CleanUpBelongToRenderFrameHost(RenderFrameHost* render_frame_host);
 153
 154   void OnEnteredFullscreen(int player_id);
 155   void OnExitedFullscreen(int player_id);
 156   WebContents* GetWebContents(int player_id) override;
 157
 158 #if defined(TIZEN_EXTERNAL_MEDIA_EVENT)
 159   // Handles play/pause events from bluetooth or headphones.
 160   void OnMediaKeyDownEvent(int player_id, const char* keyname);
 161 #endif
 162
 163   void OnGetStartDate(int player_id, double* start_date);
 164
 165  protected:
 166   // Clients must use Create() or subclass constructor.
 167   BrowserMediaPlayerManagerEfl();
 168
 169   void AddPlayer(int player_id, media::MediaPlayerInterfaceEfl* player);
 170   void RemovePlayer(int player_id);
 171
 172   // To continue initializing of other players in queue.
 173   void OnInitComplete(int player_id, bool success) override;
 174
 175   // To manage resumed/suspended player id.
 176   void OnResumeComplete(int player_id) override;
 177   void OnSuspendComplete(int player_id) override;
 178
 179   // Helper function to send messages to RenderFrameObserver.
 180   bool Send(int player_id, IPC::Message* msg);
 181
 182   RenderFrameHost* GetRenderFrameHostFromPlayerID(int player_id) const;
 183   int GetRoutingID(int player_id) const;
 184
 185   void OnPlayerSuspendRequest(int player_id) override;
 186
 187 #if defined(TIZEN_MULTIMEDIA_SUPPORT)
 188   void OnSystemVolumeChange(int player_id, int volume) override;
 189 #endif
 190
 191  private:
 192   friend struct base::DefaultSingletonTraits<BrowserMediaPlayerManagerEfl>;
 193
 194   void PauseOtherPlayers(int player_id);
 195
 196   // MediaCapabilityManager graph traversing API
 197   bool ActivatePlayer(media::MediaPlayerInterfaceEfl* player);
 198   void Activate(media::MediaPlayerInterfaceEfl* player);
 199   void Deactivate(media::MediaPlayerInterfaceEfl* player);
 200   void Show(media::MediaPlayerInterfaceEfl* player);
 201   void Hide(media::MediaPlayerInterfaceEfl* player);
 202   void SuspendPlayer(media::MediaPlayerInterfaceEfl* player, bool preempted);
 203   std::function<bool(media::MediaPlayerInterfaceEfl*)> PreemptPlayerCb();
 204 #if defined(OS_TIZEN_TV_PRODUCT)
 205   double getAmplifiedVolume(double volume);
 206 #endif
 207 #if defined(TIZEN_EXTERNAL_MEDIA_EVENT)
 208   Ecore_Wl_Window* GetEvasObject(RenderFrameHost* render_frame_host);
 209 #endif
 210
 211   // An array of managed players.
 212   base::ScopedPtrHashMap<int, std::unique_ptr<media::MediaPlayerInterfaceEfl>>
 213       players_;
 214
 215   typedef std::unordered_map<int, RenderFrameHost*> RenderFrameHostMap;
 216   RenderFrameHostMap render_frame_host_map_;
 217
 218   media::MediaCapabilityManager<media::LongestConflictStrategy>
 219       media_capability_manager_;
 220
 221 #if defined(TIZEN_EXTERNAL_MEDIA_EVENT)
 222   base::ExternalInputDeviceController* external_event_controller_ = nullptr;
 223 #endif
 224
 225   DISALLOW_COPY_AND_ASSIGN(BrowserMediaPlayerManagerEfl);
 226 };
 227
 228 }  // namespace content
 229
 230 #endif  // CONTENT_BROWSER_MEDIA_TIZEN_BROWSER_MEDIA_PLAYER_MANAGER_EFL_H_