media/base/android/media_player_bridge.h

   1 // Copyright (c) 2012 The Chromium Authors. 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_ANDROID_MEDIA_PLAYER_BRIDGE_H_
   6 #define MEDIA_BASE_ANDROID_MEDIA_PLAYER_BRIDGE_H_
   7
   8 #include <jni.h>
   9 #include <map>
  10 #include <string>
  11
  12 #include "base/android/scoped_java_ref.h"
  13 #include "base/callback.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "base/time/time.h"
  17 #include "base/timer/timer.h"
  18 #include "media/base/android/media_player_android.h"
  19 #include "media/base/android/media_player_listener.h"
  20 #include "url/gurl.h"
  21
  22 namespace media {
  23
  24 class MediaPlayerManager;
  25
  26 // This class serves as a bridge between the native code and Android MediaPlayer
  27 // Java class. For more information on Android MediaPlayer, check
  28 // http://developer.android.com/reference/android/media/MediaPlayer.html
  29 // The actual Android MediaPlayer instance is created lazily when Start(),
  30 // Pause(), SeekTo() gets called. As a result, media information may not
  31 // be available until one of those operations is performed. After that, we
  32 // will cache those information in case the mediaplayer gets released.
  33 // The class uses the corresponding MediaPlayerBridge Java class to talk to
  34 // the Android MediaPlayer instance.
  35 class MEDIA_EXPORT MediaPlayerBridge : public MediaPlayerAndroid {
  36  public:
  37   static bool RegisterMediaPlayerBridge(JNIEnv* env);
  38
  39   // Construct a MediaPlayerBridge object. This object needs to call |manager|'s
  40   // RequestMediaResources() before decoding the media stream. This allows
  41   // |manager| to track unused resources and free them when needed. On the other
  42   // hand, it needs to call ReleaseMediaResources() when it is done with
  43   // decoding. MediaPlayerBridge also forwards Android MediaPlayer callbacks to
  44   // the |manager| when needed.
  45   MediaPlayerBridge(int player_id,
  46                     const GURL& url,
  47                     const GURL& first_party_for_cookies,
  48                     bool hide_url_log,
  49                     MediaPlayerManager* manager);
  50   virtual ~MediaPlayerBridge();
  51
  52   // Initialize this object and extract the metadata from the media.
  53   virtual void Initialize();
  54
  55   // MediaPlayerAndroid implementation.
  56   virtual void SetVideoSurface(gfx::ScopedJavaSurface surface) OVERRIDE;
  57   virtual void Start() OVERRIDE;
  58   virtual void Pause() OVERRIDE;
  59   virtual void SeekTo(base::TimeDelta time) OVERRIDE;
  60   virtual void Release() OVERRIDE;
  61   virtual void SetVolume(double volume) OVERRIDE;
  62   virtual int GetVideoWidth() OVERRIDE;
  63   virtual int GetVideoHeight() OVERRIDE;
  64   virtual base::TimeDelta GetCurrentTime() OVERRIDE;
  65   virtual base::TimeDelta GetDuration() OVERRIDE;
  66   virtual bool IsPlaying() OVERRIDE;
  67   virtual bool CanPause() OVERRIDE;
  68   virtual bool CanSeekForward() OVERRIDE;
  69   virtual bool CanSeekBackward() OVERRIDE;
  70   virtual bool IsPlayerReady() OVERRIDE;
  71   virtual GURL GetUrl() OVERRIDE;
  72   virtual GURL GetFirstPartyForCookies() OVERRIDE;
  73
  74  protected:
  75   void SetJavaMediaPlayerBridge(jobject j_media_player_bridge);
  76   void SetMediaPlayerListener();
  77   void SetDuration(base::TimeDelta time);
  78
  79   // MediaPlayerAndroid implementation.
  80   virtual void OnVideoSizeChanged(int width, int height) OVERRIDE;
  81   virtual void OnPlaybackComplete() OVERRIDE;
  82   virtual void OnMediaInterrupted() OVERRIDE;
  83
  84   virtual void PendingSeekInternal(base::TimeDelta time);
  85
  86   // Prepare the player for playback, asynchronously. When succeeds,
  87   // OnMediaPrepared() will be called. Otherwise, OnMediaError() will
  88   // be called with an error type.
  89   virtual void Prepare();
  90   void OnMediaPrepared();
  91
  92   // Create the corresponding Java class instance.
  93   virtual void CreateJavaMediaPlayerBridge();
  94
  95  private:
  96   // Set the data source for the media player.
  97   void SetDataSource(const std::string& url);
  98
  99   // Functions that implements media player control.
 100   void StartInternal();
 101   void PauseInternal();
 102   void SeekInternal(base::TimeDelta time);
 103
 104   // Get allowed operations from the player.
 105   void GetAllowedOperations();
 106
 107   // Callback function passed to |resource_getter_|. Called when the cookies
 108   // are retrieved.
 109   void OnCookiesRetrieved(const std::string& cookies);
 110
 111   // Extract the media metadata from a url, asynchronously.
 112   // OnMediaMetadataExtracted() will be called when this call finishes.
 113   void ExtractMediaMetadata(const std::string& url);
 114   void OnMediaMetadataExtracted(base::TimeDelta duration, int width, int height,
 115                                 bool success);
 116
 117   // Whether the player is prepared for playback.
 118   bool prepared_;
 119
 120   // Pending play event while player is preparing.
 121   bool pending_play_;
 122
 123   // Pending seek time while player is preparing.
 124   base::TimeDelta pending_seek_;
 125
 126   // Url for playback.
 127   GURL url_;
 128
 129   // First party url for cookies.
 130   GURL first_party_for_cookies_;
 131
 132   // Hide url log from media player.
 133   bool hide_url_log_;
 134
 135   // Stats about the media.
 136   base::TimeDelta duration_;
 137   int width_;
 138   int height_;
 139
 140   // Meta data about actions can be taken.
 141   bool can_pause_;
 142   bool can_seek_forward_;
 143   bool can_seek_backward_;
 144
 145   // Cookies for |url_|.
 146   std::string cookies_;
 147
 148   // Java MediaPlayerBridge instance.
 149   base::android::ScopedJavaGlobalRef<jobject> j_media_player_bridge_;
 150
 151   base::RepeatingTimer<MediaPlayerBridge> time_update_timer_;
 152
 153   // Weak pointer passed to |listener_| for callbacks.
 154   base::WeakPtrFactory<MediaPlayerBridge> weak_this_;
 155
 156   // Listener object that listens to all the media player events.
 157   MediaPlayerListener listener_;
 158
 159   friend class MediaPlayerListener;
 160   DISALLOW_COPY_AND_ASSIGN(MediaPlayerBridge);
 161 };
 162
 163 }  // namespace media
 164
 165 #endif  // MEDIA_BASE_ANDROID_MEDIA_PLAYER_BRIDGE_H_