src/xwalk/tizen/browser/browser_mediaplayer_manager.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Copyright (c) 2013 Intel Corporation. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5
   6 #include "xwalk/tizen/browser/browser_mediaplayer_manager.h"
   7
   8 #include "content/public/browser/render_view_host.h"
   9 #include "content/public/browser/web_contents.h"
  10 #include "xwalk/tizen/browser/audio_session_manager_init.h"
  11 #include "xwalk/tizen/common/media_player_messages.h"
  12
  13 namespace tizen {
  14
  15 BrowserMediaPlayerManager::BrowserMediaPlayerManager(
  16     content::RenderViewHost* render_view_host)
  17     : WebContentsObserver(content::WebContents::FromRenderViewHost(
  18           render_view_host)) {
  19 }
  20
  21 BrowserMediaPlayerManager::~BrowserMediaPlayerManager() {}
  22
  23 BrowserMediaPlayerManager* BrowserMediaPlayerManager::Create(
  24     content::RenderViewHost* render_view_host) {
  25   return new BrowserMediaPlayerManager(render_view_host);
  26 }
  27
  28 bool BrowserMediaPlayerManager::OnMessageReceived(const IPC::Message& msg) {
  29   bool handled = true;
  30   IPC_BEGIN_MESSAGE_MAP(BrowserMediaPlayerManager, msg)
  31     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_MediaPlayerInitialize, OnInitialize)
  32     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_MediaPlayerStarted, OnStart)
  33     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_MediaPlayerPaused, OnPause)
  34     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_DestroyMediaPlayer, OnDestroyPlayer)
  35     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_DestroyAllMediaPlayers,
  36                         OnDestroyAllMediaPlayers)
  37     IPC_MESSAGE_UNHANDLED(handled = false)
  38   IPC_END_MESSAGE_MAP()
  39
  40   return handled;
  41 }
  42
  43 AudioSessionManager* BrowserMediaPlayerManager::GetAudioSessionManager(
  44     MediaPlayerID player_id) {
  45   for (ScopedVector<AudioSessionManager>::iterator it =
  46       audio_session_managers_.begin(); it != audio_session_managers_.end();
  47       ++it) {
  48     if ((*it)->player_id() == player_id)
  49       return *it;
  50   }
  51
  52   return NULL;
  53 }
  54
  55 ASM_cb_result_t BrowserMediaPlayerManager::AudioSessionEventPause(
  56     ASM_event_sources_t event_source,
  57     MediaPlayerID player_id) {
  58   switch (event_source) {
  59     case ASM_EVENT_SOURCE_CALL_START:
  60     case ASM_EVENT_SOURCE_ALARM_START:
  61     case ASM_EVENT_SOURCE_MEDIA:
  62     case ASM_EVENT_SOURCE_EMERGENCY_START:
  63     case ASM_EVENT_SOURCE_OTHER_PLAYER_APP:
  64     case ASM_EVENT_SOURCE_RESOURCE_CONFLICT:
  65       Send(new MediaPlayerMsg_MediaPlayerPause(routing_id(), player_id));
  66       return ASM_CB_RES_PAUSE;
  67     default:
  68       return ASM_CB_RES_NONE;
  69     }
  70 }
  71
  72 ASM_cb_result_t BrowserMediaPlayerManager::AudioSessionEventPlay(
  73     ASM_event_sources_t event_source,
  74     MediaPlayerID player_id) {
  75   switch (event_source) {
  76     case ASM_EVENT_SOURCE_ALARM_END:
  77       Send(new MediaPlayerMsg_MediaPlayerPlay(routing_id(), player_id));
  78       return ASM_CB_RES_PLAYING;
  79     default:
  80       return ASM_CB_RES_NONE;
  81   }
  82 }
  83
  84 static ASM_cb_result_t AudioSessionNotifyCallback(
  85     int handle,
  86     ASM_event_sources_t event_source,
  87     ASM_sound_commands_t command,
  88     unsigned int sound_status,
  89     void* callback_data) {
  90   AudioSessionManager* data =
  91       static_cast<AudioSessionManager*>(callback_data);
  92
  93   BrowserMediaPlayerManager* manager = data->media_player_manager();
  94   if (command == ASM_COMMAND_STOP || command == ASM_COMMAND_PAUSE)
  95     return manager->AudioSessionEventPause(event_source, data->player_id());
  96   if (command == ASM_COMMAND_PLAY || command == ASM_COMMAND_RESUME)
  97     return manager->AudioSessionEventPlay(event_source, data->player_id());
  98
  99   return ASM_CB_RES_NONE;
 100 }
 101
 102 void BrowserMediaPlayerManager::OnInitialize(
 103     MediaPlayerID player_id,
 104     int process_id,
 105     const GURL& url) {
 106
 107   // Initialize the audio session manager library.
 108   if (!InitializeAudioSessionManager()) {
 109     DLOG(WARNING) << "Failed on loading the audio session manager library";
 110     return;
 111   }
 112
 113   RemoveAudioSessionManager(player_id);
 114   AudioSessionManager* session_manager =
 115       new AudioSessionManager(this, player_id, process_id);
 116
 117   session_manager->RegisterAudioSessionManager(
 118       ASM_EVENT_SHARE_MMPLAYER,
 119       AudioSessionNotifyCallback,
 120       session_manager);
 121   session_manager->SetSoundState(ASM_STATE_PAUSE);
 122
 123   AddAudioSessionManager(session_manager);
 124 }
 125
 126 void BrowserMediaPlayerManager::OnDestroyAllMediaPlayers() {
 127   audio_session_managers_.clear();
 128 }
 129
 130 void BrowserMediaPlayerManager::OnDestroyPlayer(MediaPlayerID player_id) {
 131   RemoveAudioSessionManager(player_id);
 132 }
 133
 134 void BrowserMediaPlayerManager::OnPause(MediaPlayerID player_id) {
 135   AudioSessionManager* session_manager = GetAudioSessionManager(player_id);
 136   if (session_manager)
 137     session_manager->SetSoundState(ASM_STATE_PAUSE);
 138 }
 139
 140 void BrowserMediaPlayerManager::OnStart(MediaPlayerID player_id) {
 141   AudioSessionManager* session_manager = GetAudioSessionManager(player_id);
 142   if (session_manager)
 143     session_manager->SetSoundState(ASM_STATE_PLAYING);
 144 }
 145
 146 void BrowserMediaPlayerManager::AddAudioSessionManager(
 147     AudioSessionManager* session_manager) {
 148   DCHECK(!GetAudioSessionManager(session_manager->player_id()));
 149   audio_session_managers_.push_back(session_manager);
 150 }
 151
 152 void BrowserMediaPlayerManager::RemoveAudioSessionManager(
 153     MediaPlayerID player_id) {
 154   for (ScopedVector<AudioSessionManager>::iterator it =
 155       audio_session_managers_.begin(); it != audio_session_managers_.end();
 156       ++it) {
 157     if ((*it)->player_id() == player_id) {
 158       audio_session_managers_.erase(it);
 159       break;
 160     }
 161   }
 162 }
 163
 164 }  // namespace tizen