services/media_session/audio_focus_request.h

   1 // Copyright 2019 The Chromium Authors
   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 SERVICES_MEDIA_SESSION_AUDIO_FOCUS_REQUEST_H_
   6 #define SERVICES_MEDIA_SESSION_AUDIO_FOCUS_REQUEST_H_
   7
   8 #include "base/functional/callback_forward.h"
   9 #include "base/memory/weak_ptr.h"
  10 #include "mojo/public/cpp/bindings/receiver.h"
  11 #include "mojo/public/cpp/bindings/remote.h"
  12 #include "services/media_session/public/mojom/audio_focus.mojom.h"
  13 #include "services/media_session/public/mojom/media_controller.mojom.h"
  14
  15 namespace media_session {
  16
  17 using GetMediaImageBitmapCallback = base::OnceCallback<void(const SkBitmap&)>;
  18
  19 class AudioFocusManager;
  20 struct EnforcementState;
  21 class MediaController;
  22
  23 class AudioFocusRequest : public mojom::AudioFocusRequestClient {
  24  public:
  25   AudioFocusRequest(
  26       base::WeakPtr<AudioFocusManager> owner,
  27       mojo::PendingReceiver<mojom::AudioFocusRequestClient> receiver,
  28       mojo::PendingRemote<mojom::MediaSession> session,
  29       mojom::MediaSessionInfoPtr session_info,
  30       mojom::AudioFocusType audio_focus_type,
  31       const base::UnguessableToken& id,
  32       const std::string& source_name,
  33       const base::UnguessableToken& group_id,
  34       const base::UnguessableToken& identity);
  35
  36   AudioFocusRequest(const AudioFocusRequest&) = delete;
  37   AudioFocusRequest& operator=(const AudioFocusRequest&) = delete;
  38
  39   ~AudioFocusRequest() override;
  40
  41   // mojom::AudioFocusRequestClient.
  42   void RequestAudioFocus(mojom::MediaSessionInfoPtr session_info,
  43                          mojom::AudioFocusType type,
  44                          RequestAudioFocusCallback callback) override;
  45   void AbandonAudioFocus() override;
  46   void MediaSessionInfoChanged(mojom::MediaSessionInfoPtr info) override;
  47
  48   // The current audio focus type that this request has.
  49   mojom::AudioFocusType audio_focus_type() const { return audio_focus_type_; }
  50   void set_audio_focus_type(mojom::AudioFocusType type) {
  51     audio_focus_type_ = type;
  52   }
  53
  54   // Returns whether the underyling media session is currently suspended.
  55   bool IsSuspended() const;
  56
  57   // Returns the state of this audio focus request.
  58   mojom::AudioFocusRequestStatePtr ToAudioFocusRequestState() const;
  59
  60   // Bind a mojo media controller to control the underlying media session.
  61   void BindToMediaController(
  62       mojo::PendingReceiver<mojom::MediaController> receiver);
  63
  64   // Suspends the underlying media session.
  65   void Suspend(const EnforcementState& state);
  66
  67   // If the underlying media session previously suspended this session then this
  68   // will resume it and apply any delayed action.
  69   void ReleaseTransientHold();
  70
  71   // Perform a UI action (play/pause/stop). This may be delayed if the service
  72   // has transiently suspended the session.
  73   void PerformUIAction(mojom::MediaSessionAction action);
  74
  75   // Retrieves the bitmap associated with a |image|.
  76   void GetMediaImageBitmap(const MediaImage& image,
  77                            int minimum_size_px,
  78                            int desired_size_px,
  79                            GetMediaImageBitmapCallback callback);
  80
  81   mojom::MediaSession* ipc() { return session_.get(); }
  82   const mojom::MediaSessionInfoPtr& info() const { return session_info_; }
  83   const base::UnguessableToken& id() const { return id_; }
  84   const std::string& source_name() const { return source_name_; }
  85   const base::UnguessableToken& group_id() const { return group_id_; }
  86   const base::UnguessableToken& identity() const { return identity_; }
  87
  88  private:
  89   void SetSessionInfo(mojom::MediaSessionInfoPtr session_info);
  90   void OnConnectionError();
  91
  92   void OnImageDownloaded(GetMediaImageBitmapCallback callback,
  93                          const SkBitmap& bitmap);
  94
  95   bool encountered_error_ = false;
  96   bool was_suspended_ = false;
  97
  98   std::unique_ptr<MediaController> controller_;
  99
 100   mojo::Remote<mojom::MediaSession> session_;
 101   mojom::MediaSessionInfoPtr session_info_;
 102   mojom::AudioFocusType audio_focus_type_;
 103
 104   mojo::Receiver<mojom::AudioFocusRequestClient> receiver_;
 105
 106   // The action to apply when the transient hold is released.
 107   absl::optional<mojom::MediaSessionAction> delayed_action_;
 108
 109   // The ID of the audio focus request.
 110   base::UnguessableToken const id_;
 111
 112   // The name of the source that created this audio focus request (used for
 113   // metrics).
 114   std::string const source_name_;
 115
 116   // The group ID of the audio focus request.
 117   base::UnguessableToken const group_id_;
 118
 119   // The identity that requested audio focus.
 120   base::UnguessableToken const identity_;
 121
 122   // Weak pointer to the owning |AudioFocusManager| instance.
 123   const base::WeakPtr<AudioFocusManager> owner_;
 124 };
 125
 126 }  // namespace media_session
 127
 128 #endif  // SERVICES_MEDIA_SESSION_AUDIO_FOCUS_REQUEST_H_