src/video-player.c

   1 /*
   2  * Copyright (c) [2012] Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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
  17
  18 #include <app.h>
  19 #include <glib.h>
  20 #include <pmapi.h>
  21 #include "mp-util.h"
  22 #include "mp-video-log.h"
  23 #include "video-player.h"
  24 #include "mp-video-app-ctrl.h"
  25 #include "mp-util-media-service.h"
  26 #include "mp-video-string-define.h"
  27 #include "mp-external-ug.h"
  28 #include "mp-video-service-ctrl.h"
  29
  30 static void appResume(void *pUserData);
  31
  32 static bool bIsForeground = FALSE;
  33
  34 static Ecore_Idler *pInitIdlerHandle = NULL;
  35
  36 static Eina_Bool _mp_focus_in_cb(void *pUserData, int nType, void *pEvent)
  37 {
  38         if (!pUserData) {
  39                 VideoLogInfo("[ERR] No exist pUserData.");
  40                 return ECORE_CALLBACK_PASS_ON;
  41         }
  42
  43         if (!pEvent) {
  44                 VideoLogInfo("[ERR] No exist pEvent.");
  45                 return ECORE_CALLBACK_PASS_ON;
  46         }
  47
  48         VideoAppData *pAppData = (VideoAppData *)pUserData;
  49
  50         Ecore_X_Event_Window_Focus_In *ev = (Ecore_X_Event_Window_Focus_In *)pEvent;
  51
  52         if (ev->win == MpUtilGetMainWindowXID())
  53         {
  54                 if(bIsForeground && MpVideoAppCtrlIsTopView(pUserData))
  55                 {
  56                         VideoLogInfo("resume for focus in");
  57                         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlResume(pAppData);
  58                 }
  59         }
  60
  61         return ECORE_CALLBACK_PASS_ON;
  62 }
  63
  64 static Eina_Bool _mp_focus_out_cb(void *pUserData, int nType, void *pEvent)
  65 {
  66         if (!pUserData) {
  67                 VideoLogInfo("[ERR] No exist pUserData.");
  68                 return ECORE_CALLBACK_PASS_ON;
  69         }
  70
  71         if (!pEvent) {
  72                 VideoLogInfo("[ERR] No exist pEvent.");
  73                 return ECORE_CALLBACK_PASS_ON;
  74         }
  75
  76         VideoAppData *pAppData = (VideoAppData *)pUserData;
  77
  78         Ecore_X_Event_Window_Focus_Out *ev = (Ecore_X_Event_Window_Focus_Out *)pEvent;
  79
  80         if (ev->win == MpUtilGetMainWindowXID())
  81         {
  82                 if(bIsForeground && MpVideoAppCtrlIsTopView(pUserData))
  83                 {
  84                         VideoLogInfo("pause for focus in");
  85                         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPause(pAppData);
  86                 }
  87         }
  88
  89         return ECORE_CALLBACK_PASS_ON;
  90
  91 }
  92
  93
  94 static Eina_Bool _mp_client_message_cb(void *pUserData, int nType, void *pEvent)
  95 {
  96         if (!pUserData) {
  97                 VideoLogInfo("[ERR] No exist pUserData.");
  98                 return ECORE_CALLBACK_PASS_ON;
  99         }
 100
 101         if (!pEvent) {
 102                 VideoLogInfo("[ERR] No exist pEvent.");
 103                 return ECORE_CALLBACK_PASS_ON;
 104         }
 105
 106         VideoAppData *pAppData = (VideoAppData *)pUserData;
 107
 108         Ecore_X_Event_Client_Message *ev = (Ecore_X_Event_Client_Message *) pEvent;
 109
 110         if (ev->message_type == ECORE_X_ATOM_E_ILLUME_QUICKPANEL_STATE)
 111         {
 112                 if (ev->data.l[0] == ECORE_X_ATOM_E_ILLUME_QUICKPANEL_ON)
 113                 {
 114                         VideoLogInfo("quickpanel show");
 115                         if(MpVideoAppCtrlIsTopView(pUserData) && bIsForeground)
 116                         {
 117                                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPause(pAppData);
 118                         }
 119                 }
 120                 else
 121                 {
 122                         VideoLogInfo("quickpanel hide");
 123                         if(MpVideoAppCtrlIsTopView(pUserData) && bIsForeground)
 124                         {
 125                                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlResume(pAppData);
 126                         }
 127                 }
 128         }
 129
 130         return ECORE_CALLBACK_PASS_ON;
 131 }
 132
 133 static Eina_Bool _mp_app_init_idler_cb(void *pUserData)
 134 {
 135         if (!pUserData) {
 136                 VideoLogInfo("[ERR] No exist pUserData.");
 137                 return ECORE_CALLBACK_CANCEL;
 138         }
 139         VideoLogInfo("");
 140
 141         VideoAppData *pAppData = (VideoAppData *)pUserData;
 142
 143         ecore_event_handler_add(ECORE_X_EVENT_CLIENT_MESSAGE, _mp_client_message_cb, (void *)pAppData);
 144         ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_IN, _mp_focus_in_cb, (void *)pAppData);
 145         ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT, _mp_focus_out_cb, (void *)pAppData);
 146
 147         pInitIdlerHandle = NULL;
 148
 149         return ECORE_CALLBACK_CANCEL;
 150
 151 }
 152
 153 static void _mp_alloc_service_value(void *pUserData)
 154 {
 155         VideoLogInfo("");
 156
 157         if (!pUserData) {
 158                 VideoLogInfo("[ERR] No exist pUserData.");
 159                 return;
 160         }
 161
 162
 163         VideoAppData *pAppData = (VideoAppData *)pUserData;
 164
 165         pAppData->szSubtitle = calloc(1, sizeof(char) * STR_LEN_MAX);
 166         pAppData->szVideoTitle = calloc(1, sizeof(char) * STR_LEN_MAX);
 167
 168         pAppData->szMediaUri = calloc(1, sizeof(char) * STR_LEN_MAX);
 169         pAppData->szPreMediaUri = calloc(1, sizeof(char) * STR_LEN_MAX);
 170         pAppData->szNextMediaUri = calloc(1, sizeof(char) * STR_LEN_MAX);
 171
 172         pAppData->szProxyAddress = calloc(1, sizeof(char) * STR_LEN_MAX);
 173         pAppData->szUserAgent = calloc(1, sizeof(char) * STR_LEN_MAX);
 174         pAppData->szCookie = calloc(1, sizeof(char) * STR_LEN_MAX);
 175 }
 176
 177
 178 static void _mp_free_service_value(void *pUserData)
 179 {
 180         VideoLogInfo("");
 181
 182         if (!pUserData) {
 183                 VideoLogInfo("[ERR] No exist pUserData.");
 184                 return;
 185         }
 186
 187
 188         VideoAppData *pAppData = (VideoAppData *)pUserData;
 189
 190         if(pAppData->szSubtitle)
 191         {
 192                 free(pAppData->szSubtitle);
 193                 pAppData->szSubtitle = NULL;
 194         }
 195
 196         if(pAppData->szVideoTitle)
 197         {
 198                 free(pAppData->szVideoTitle);
 199                 pAppData->szVideoTitle = NULL;
 200         }
 201
 202         if(pAppData->szMediaUri)
 203         {
 204                 free(pAppData->szMediaUri);
 205                 pAppData->szMediaUri = NULL;
 206         }
 207         if(pAppData->szPreMediaUri)
 208         {
 209                 free(pAppData->szPreMediaUri);
 210                 pAppData->szPreMediaUri = NULL;
 211         }
 212
 213         if(pAppData->szNextMediaUri)
 214         {
 215                 free(pAppData->szNextMediaUri);
 216                 pAppData->szNextMediaUri = NULL;
 217         }
 218
 219         if(pAppData->szProxyAddress)
 220         {
 221                 free(pAppData->szProxyAddress);
 222                 pAppData->szProxyAddress = NULL;
 223         }
 224
 225         if(pAppData->szUserAgent)
 226         {
 227                 free(pAppData->szUserAgent);
 228                 pAppData->szUserAgent = NULL;
 229         }
 230
 231         if(pAppData->szCookie)
 232         {
 233                 free(pAppData->szCookie);
 234                 pAppData->szCookie = NULL;
 235         }
 236 }
 237
 238 static bool appCreate(void *pUserData)
 239 {
 240         VideoLogInfo("");
 241
 242         if (!pUserData) {
 243                 VideoLogInfo("[ERR] No exist pUserData.");
 244                 return FALSE;
 245         }
 246
 247         VideoAppData *pAppData = (VideoAppData *)pUserData;
 248
 249         _mp_alloc_service_value((void *)pAppData);
 250
 251         pInitIdlerHandle = ecore_idler_add(_mp_app_init_idler_cb, (void *)pAppData);
 252
 253 #ifdef TARGET
 254         elm_config_preferred_engine_set("opengl_x11");
 255 #else
 256         elm_config_preferred_engine_set("software_x11");
 257 #endif
 258
 259         elm_theme_extension_add(NULL, VIDEO_CUSTOM_THEME);
 260
 261
 262         MpUtilInitSession();
 263
 264         if(!MpUtilMMCstatusNoti(pAppData))
 265         {
 266                 VideoLogError("[ERR] Fail to set MMC notification.");
 267         }
 268
 269         bIsForeground = FALSE;
 270
 271         MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 272
 273         return TRUE;
 274 }
 275
 276 static void appService(service_h pAppSvcHandle, void *pUserData)
 277 {
 278         VideoLogInfo("");
 279
 280         if(!pUserData)
 281         {
 282                 VideoLogInfo("[ERR] No exist pUserData.");
 283                 bIsForeground = FALSE;
 284                 MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 285                 return;
 286         }
 287
 288         VideoAppData *pAppData = (VideoAppData *)pUserData;
 289
 290         char* szGetMediaUri = NULL;
 291
 292         if(!pAppSvcHandle)
 293         {
 294                 VideoLogInfo("[ERR] No exist pBundle.");
 295                 bIsForeground = FALSE;
 296                 MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 297                 return;
 298         }
 299
 300         if(pAppData->pMainWindow == NULL)
 301         {
 302                 VideoLogInfo("Create main window.");
 303                 pAppData->pMainWindow = (Evas_Object *)MpUtilCreateMainWindow(PACKAGE);
 304         }
 305         else
 306         {
 307                 if(strlen(pAppData->szMediaUri) > 0)
 308                 {
 309                         MpVideoAppCtrlResetForRelaunching(pAppData);
 310                 }
 311         }
 312
 313         if(MpVideoServiceCtrlInitServiceParser((void*)pAppSvcHandle, &szGetMediaUri) == MP_ERROR_PLAYER_TYPE)
 314         {
 315                 VideoLogInfo("[ERR] Fail to init service parser.");
 316                 bIsForeground = FALSE;
 317                 MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 318                 return;
 319         }
 320
 321         if(szGetMediaUri)
 322         {
 323                 strncpy(pAppData->szMediaUri, szGetMediaUri, STR_LEN_MAX);
 324                 VideoLogInfo("szGetMediaUri : %s", pAppData->szMediaUri);
 325                 free(szGetMediaUri);
 326         }
 327         else
 328         {
 329                 VideoLogInfo("No exist szGetMediaUri");
 330         }
 331
 332         if(!MpUtilBatteryStatusNoti(pAppData))
 333         {
 334                 VideoLogInfo("[ERR] Fail to set Battery notification.");
 335                 bIsForeground = FALSE;
 336                 MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 337                 return;
 338         }
 339         bIsForeground = TRUE;
 340
 341         MpUtilMediaSvcInitSession();
 342         MpUtilSetKeyGrab(HOME_KEY, KEY_GRAB_SHARED);
 343         MpVideoAppCtrlInit(pAppData);
 344 }
 345
 346 static void appExit(void *pUserData)
 347 {
 348         VideoLogInfo("");
 349
 350         if (!pUserData) {
 351                 VideoLogInfo("[ERR] No exist pUserData.");
 352                 return;
 353         }
 354         VideoAppData *pAppData = (VideoAppData *)pUserData;
 355
 356         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 357
 358         MpUtilMultimediaVolumeKeyUngrab();
 359         MpUtilLcdOffForPowerButton();
 360         MpUtilSetKeyUngrab(HOME_KEY);
 361         MpUtilMultimediaKeyUngrab();
 362         MpUtilMMCstatusNotiIgnore();
 363         MpUtilBatteryStatusNotiIgnore();
 364         MpUtilFinishSession();
 365         MpUtilDeletePopupHandle();
 366         MpUtilMediaSvcDestoryVideoList();
 367         MpUtilMediaSvcFinishSession();
 368
 369         _mp_free_service_value(pUserData);
 370
 371         bIsForeground = FALSE;
 372         MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 373
 374 #ifdef TA_SVAE_PERF_FILE
 375         VP_PERF_DEINIT();
 376 #endif
 377 }
 378
 379 static void appPause(void *pUserData)
 380 {
 381         if(!pUserData)
 382         {
 383                 VideoLogInfo("No exist pUserdata handle.");
 384                 return;
 385         }
 386
 387         VideoLogInfo("");
 388
 389         MpUtilMultimediaVolumeKeyUngrab();
 390
 391         VideoAppData *pAppData = (VideoAppData *)pUserData;
 392
 393         if(MpVideoAppCtrlIsCheckCallStatus())
 394         {
 395                 VideoLogInfo("Skip for Call Pause.");
 396                 MpVideoAppCtrlInitCheckCallStatus();
 397         }
 398
 399         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
 400
 401         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
 402                         nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
 403                         nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
 404                         nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
 405                         nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
 406         {
 407                 VideoLogInfo("Pause application at video player.");
 408                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 409         }
 410         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
 411         {
 412                 VideoLogInfo("Pause application at streaming player.");
 413                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 414         }
 415
 416         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlHideLayout(pAppData);
 417
 418         MpUtilDeletePopupHandle();
 419
 420         elm_win_indicator_mode_set(pAppData->pMainWindow, ELM_WIN_INDICATOR_SHOW);
 421
 422         bIsForeground = FALSE;
 423         MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 424
 425         evas_object_hide(pAppData->pMainWindow);
 426 }
 427
 428 static void appResume(void *pUserData)
 429 {
 430         if(!pUserData)
 431         {
 432                 VideoLogInfo("No exist pUserdata handle.");
 433                 return;
 434         }
 435
 436         VideoLogInfo("");
 437
 438         VideoAppData *pAppData = (VideoAppData *)pUserData;
 439
 440         if(bIsForeground)
 441         {
 442                 VideoLogInfo("Defence overlap launching.");
 443                 return;
 444         }
 445
 446         MpUtilMultimediaVolumeKeyGrab();
 447
 448         if(!MpVideoAppCtrlIsTopView(pUserData))
 449         {
 450                 VideoLogError("Overlay is not staied in top.");
 451                 return;
 452         }
 453
 454         if(MpVideoAppCtrlIsExistPlayerHandle())
 455         {
 456                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlResume(pAppData);
 457         }
 458         else
 459         {
 460                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStartByAppResume(pAppData);
 461         }
 462
 463         elm_win_indicator_mode_set(pAppData->pMainWindow, ELM_WIN_INDICATOR_SHOW);
 464
 465         bIsForeground = TRUE;
 466         MpVideoAppCtrlSetForCheckingForegroundwindow(TRUE);
 467
 468         evas_object_show(pAppData->pMainWindow);
 469 }
 470
 471 static void appRotate(app_device_orientation_e rotateState, void *pUserData)
 472 {
 473         VideoLogInfo("");
 474
 475         int nCurRotate = 0;
 476
 477         switch(rotateState)
 478         {
 479         case APP_DEVICE_ORIENTATION_0:
 480                 VideoLogInfo("VIDEO_ROTATE_PORTRAIT_NORMAL");
 481                 nCurRotate = VIDEO_ROTATE_PORTRAIT_NORMAL;
 482                 break;
 483
 484         case APP_DEVICE_ORIENTATION_90:
 485                 VideoLogInfo("VIDEO_ROTATE_LANDSCAPE_REVERSE");
 486                 nCurRotate = VIDEO_ROTATE_LANDSCAPE_REVERSE;
 487                 break;
 488
 489         case APP_DEVICE_ORIENTATION_180:
 490                 VideoLogInfo("VIDEO_ROTATE_PORTRAIT_REVERSE");
 491                 nCurRotate = VIDEO_ROTATE_PORTRAIT_REVERSE;
 492                 break;
 493
 494         case APP_DEVICE_ORIENTATION_270:
 495                 VideoLogInfo("VIDEO_ROTATE_LANDSCAPE_NORMAL");
 496                 nCurRotate = VIDEO_ROTATE_LANDSCAPE_NORMAL;
 497                 break;
 498         }
 499
 500         MpVideoAppCtrlSetRotation(nCurRotate, pUserData);
 501 }
 502
 503 int main(int argc, char *argv[])
 504 {
 505         VideoAppData pAppData;
 506         memset(&pAppData, 0, sizeof(VideoAppData));
 507
 508         app_event_callback_s st_appEventService;
 509
 510         st_appEventService.create = appCreate;
 511         st_appEventService.terminate = appExit;
 512         st_appEventService.pause = appPause;
 513         st_appEventService.resume = appResume;
 514         st_appEventService.service = appService;
 515         st_appEventService.low_memory = NULL;
 516         st_appEventService.low_battery = NULL;
 517         st_appEventService.device_orientation = appRotate;
 518         st_appEventService.language_changed = NULL;
 519         st_appEventService.region_format_changed = NULL;
 520
 521         if(app_efl_main(&argc, &argv, &st_appEventService, &pAppData) != APP_ERROR_NONE)
 522         {
 523                 VideoLogInfo("[ERR] app_efl_main().");
 524                 return -1;
 525         }
 526
 527         VideoLogInfo("escape app_efl_main() loop.");
 528
 529         return 0;
 530 }