src/modules/tizen/MMPlayer/Manager.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 #include "Manager.h"
  17 #include <mmf/mm.h>
  18 #include <mm_sound.h>
  19 #include <mm_player.h>
  20 #include <WidgetDB/WidgetDBMgr.h>
  21 #include <MMPlayer/EventOnStateChange.h>
  22 #include "MMPlayer.h"
  23
  24 using namespace std;
  25
  26 namespace WrtDeviceApis {
  27 namespace MMPlayer {
  28
  29 using namespace Api;
  30
  31 Manager::Manager()
  32 {
  33 }
  34
  35 Manager::~Manager()
  36 {
  37 }
  38
  39 void Manager::openFile(const EventOpenPtr& event)
  40 {
  41     EventRequestReceiver<EventOpen>::PostRequest(event);
  42 }
  43
  44 void Manager::play(const EventPlayPtr& event)
  45 {
  46     EventRequestReceiver<EventPlay>::PostRequest(event);
  47 }
  48
  49 void Manager::pause(const EventPausePtr& event)
  50 {
  51     EventRequestReceiver<EventPause>::PostRequest(event);
  52 }
  53
  54 void Manager::resume(const EventResumePtr& event)
  55 {
  56     EventRequestReceiver<EventResume>::PostRequest(event);
  57 }
  58
  59 void Manager::stop(const EventStopPtr& event)
  60 {
  61     EventRequestReceiver<EventStop>::PostRequest(event);
  62 }
  63
  64 void Manager::setWindow(const EventSetWindowPtr& event)
  65 {
  66     EventRequestReceiver<EventSetWindow>::PostRequest(event);
  67 }
  68
  69 void Manager::isPlaying(const EventIsPlayingPtr& event)
  70 {
  71     EventRequestReceiver<EventIsPlaying>::PostRequest(event);
  72 }
  73
  74 void Manager::getVolume(const EventGetVolumePtr& event)
  75 {
  76     EventRequestReceiver<EventGetVolume>::PostRequest(event);
  77 }
  78
  79 void Manager::OnRequestReceived(const EventOpenPtr& event)
  80 {
  81     LogDebug("Entered");
  82
  83     string fullName = event->getFilename();
  84     MMPlayerPtr player = DPL::DynamicPointerCast<MMPlayer>(event->getPlayer());
  85     if (!player) {
  86         LogError("MMPlayerPtr cast error");
  87         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
  88         return;
  89     }
  90
  91     int err;
  92     if (MM_PLAYER_STATE_NULL != player->getState()) {
  93         err = mm_player_unrealize(player->getHandler());
  94         if (MM_ERROR_NONE != err) {
  95             LogError("Can't unrealize player. Error code: " << std::hex << err);
  96             event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
  97             return;
  98         }
  99     }
 100
 101     if (!fullName.length()) {
 102         event->setExceptionCode(
 103             Commons::ExceptionCodes::InvalidArgumentException);
 104         return;
 105     }
 106
 107     //Check if current installation path should be added
 108     if ((fullName[0] != '/') && (fullName.find("://") == string::npos)) {
 109         try {
 110             std::string installationPath;
 111             Commons::IWrtWrapperPtr wrapper = event->getWrtWrapper();
 112             if (!wrapper) {
 113                 LogError("Wrt API not accessible. Can't get installation path.");
 114                 event->setExceptionCode(
 115                     Commons::ExceptionCodes::PlatformException);
 116                 return;
 117             }
 118
 119             WidgetDB::Api::IWidgetDBPtr widgetDB = WidgetDB::Api::getWidgetDB(
 120                 wrapper->getWidgetId());
 121             installationPath = widgetDB->getConfigValue(
 122                     WidgetDB::Api::ConfigAttribute::INSTALL_PATH);
 123
 124             LogInfo("Config attribute: " << installationPath);
 125             fullName.insert(0, installationPath);
 126         } catch (const Commons::Exception &ex) {
 127             LogError("Obtaining config info failed");
 128             event->setExceptionCode(ex.getCode());
 129             return;
 130         }
 131     }
 132
 133     LogDebug("Opening file: " << fullName);
 134     char *errorBuffer = NULL;
 135     err = mm_player_set_attribute(
 136             player->getHandler(), &errorBuffer, "profile_uri",
 137             fullName.c_str(), fullName.length(), NULL);
 138     if (MM_ERROR_NONE != err) {
 139         LogError(
 140             "Setting attribute error. Code: " << std::hex << err <<
 141             ". Message: " << errorBuffer);
 142         free(errorBuffer);
 143         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 144         return;
 145     }
 146
 147     err = mm_player_realize(player->getHandler());
 148     if (MM_ERROR_NONE != err) {
 149         LogError("Can't realize player. Error code:" << std::hex << err);
 150         if (static_cast<int>(MM_ERROR_PLAYER_INVALID_URI) == err) {
 151             LogDebug("x");
 152             event->setExceptionCode(
 153                 Commons::ExceptionCodes::InvalidArgumentException);
 154         } else {
 155             event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 156         }
 157         return;
 158     }
 159
 160     if (player->getEmitter()) {
 161         EventOnStateChangePtr eventStateChanged(new EventOnStateChange(
 162                                                     EventOnStateChange::OPENED));
 163         player->getEmitter()->emit(eventStateChanged);
 164     }
 165 }
 166
 167 void Manager::OnRequestReceived(const EventPlayPtr& event)
 168 {
 169     LogDebug("Entered");
 170
 171     MMPlayerPtr player = DPL::DynamicPointerCast<MMPlayer>(event->getPlayer());
 172     if (!player) {
 173         LogError("MMPlayerPtr cast error");
 174         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 175         return;
 176     }
 177
 178     //Check if player currently plays media
 179     if (MM_PLAYER_STATE_PLAYING == player->getState() || 0 ==
 180         event->getRepeatTimes()) {
 181         LogDebug("already playing");
 182         return;
 183     }
 184     player->setRepeatTimes(event->getRepeatTimes() - 1);
 185
 186     int err = mm_player_start(player->getHandler());
 187     if (MM_ERROR_NONE != err) {
 188         LogError("Can't start play. Error code: " << std::hex << err);
 189         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 190     }
 191     //Event onStateChange will be emitted trough platform callback
 192 }
 193
 194 void Manager::OnRequestReceived(const EventPausePtr& event)
 195 {
 196     LogDebug("Entered");
 197
 198     MMPlayerPtr player = DPL::DynamicPointerCast<MMPlayer>(event->getPlayer());
 199     if (!player) {
 200         LogError("MMPlayerPtr cast error");
 201         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 202         return;
 203     }
 204     if (MM_PLAYER_STATE_PLAYING != player->getState()) {
 205         return;
 206     }
 207
 208     int err = mm_player_pause(player->getHandler());
 209     if (MM_ERROR_NONE != err) {
 210         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 211     }
 212     if (player->getEmitter()) {
 213         EventOnStateChangePtr eventStateChanged(new EventOnStateChange(
 214                                                     EventOnStateChange::PAUSED));
 215         player->getEmitter()->emit(eventStateChanged);
 216     }
 217 }
 218
 219 void Manager::OnRequestReceived(const EventResumePtr& event)
 220 {
 221     LogDebug("Entered");
 222
 223     MMPlayerPtr player = DPL::DynamicPointerCast<MMPlayer>(event->getPlayer());
 224     if (!player) {
 225         LogError("MMPlayerPtr cast error");
 226         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 227         return;
 228     }
 229     if (MM_PLAYER_STATE_PAUSED != player->getState()) {
 230         return;
 231     }
 232
 233     int err = mm_player_resume(player->getHandler());
 234     if (MM_ERROR_NONE != err) {
 235         LogError("Can't resume player. Error code: " << std::hex << err);
 236         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 237     }
 238     if (player->getEmitter()) {
 239         EventOnStateChangePtr eventStateChanged(new EventOnStateChange(
 240                                                     EventOnStateChange::RESUMED));
 241         player->getEmitter()->emit(eventStateChanged);
 242     }
 243 }
 244
 245 void Manager::OnRequestReceived(const EventStopPtr& event)
 246 {
 247     LogDebug("Entered");
 248
 249     MMPlayerPtr player = DPL::DynamicPointerCast<MMPlayer>(event->getPlayer());
 250     if (!player) {
 251         LogError("MMPlayerPtr cast error");
 252         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 253         return;
 254     }
 255     if (MM_PLAYER_STATE_PLAYING != player->getState() &&
 256         MM_PLAYER_STATE_PAUSED != player->getState()) {
 257         return;
 258     }
 259
 260     int err = mm_player_stop(player->getHandler());
 261     if (MM_ERROR_NONE != err) {
 262         LogError("Can't stop player. Error code: " << std::hex << err);
 263         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 264     }
 265
 266     if (player->getEmitter()) {
 267         EventOnStateChangePtr eventStateChanged(new EventOnStateChange(
 268                                                     EventOnStateChange::STOPPED));
 269         player->getEmitter()->emit(eventStateChanged);
 270     }
 271 }
 272
 273 void Manager::OnRequestReceived(const EventSetWindowPtr& /*event*/)
 274 {
 275     LogDebug("Entered");
 276     LogError("Not implemented");
 277     //TODO: set display parameter, when xID will be available
 278 }
 279
 280 void Manager::OnRequestReceived(const EventIsPlayingPtr& event)
 281 {
 282     LogDebug("Entered");
 283
 284     MMPlayerPtr player = DPL::DynamicPointerCast<MMPlayer>(event->getPlayer());
 285     Try
 286     {
 287         if (!player) {
 288             LogError("MMPlayerPtr cast error");
 289             event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 290             return;
 291         }
 292         event->setIsPlaying(MM_PLAYER_STATE_PLAYING == player->getState());
 293     }
 294     Catch(Commons::PlatformException)
 295     {
 296         LogError("Can't get player status.");
 297         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 298         return;
 299     }
 300 }
 301
 302 void Manager::OnRequestReceived(const EventGetVolumePtr& event)
 303 {
 304     LogDebug("Entered");
 305     unsigned int volume = 0;
 306     int steps = 0;
 307
 308     int err = mm_sound_volume_get_step(VOLUME_TYPE_MEDIA, &steps);
 309     if (MM_ERROR_NONE != err) {
 310         LogError(
 311             "Can't get volume steps count. Error code: " << std::hex <<
 312             err);
 313         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 314         return;
 315     }
 316     LogInfo("Volume steps count: " << steps);
 317     try
 318     {
 319         err = mm_sound_volume_get_value(VOLUME_TYPE_MEDIA, &volume);
 320         if (MM_ERROR_NONE != err) {
 321             LogError(
 322                 "Can't get player's volume. Error code: " << std::hex <<
 323                 err);
 324             Throw(Commons::UnknownException);
 325         }
 326         LogInfo("Platform player's volume: " << volume);
 327         if (steps > 1) {
 328             event->setVolume((10.0 * volume) / (steps - 1));
 329         } else {
 330             LogError("no steps defined");
 331             event->setVolume(0);
 332         }
 333     }
 334     catch (const Commons::UnknownException &ex)
 335     {
 336         LogError("Can't scale the volume");
 337         event->setExceptionCode(Commons::ExceptionCodes::PlatformException);
 338     }
 339 }
 340
 341 }
 342 }
 343