src/video-player.c

   1 /*
   2  * Copyright (c) [2012] Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (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         MpUtilVolumeTypeSet();
 264
 265         if(!MpUtilMMCstatusNoti(pAppData))
 266         {
 267                 VideoLogError("[ERR] Fail to set MMC notification.");
 268         }
 269
 270         bIsForeground = FALSE;
 271
 272         MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 273
 274         return TRUE;
 275 }
 276
 277 static void appService(service_h pAppSvcHandle, void *pUserData)
 278 {
 279         VideoLogInfo("");
 280
 281         if(!pUserData)
 282         {
 283                 VideoLogInfo("[ERR] No exist pUserData.");
 284                 bIsForeground = FALSE;
 285                 MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 286                 return;
 287         }
 288
 289         VideoAppData *pAppData = (VideoAppData *)pUserData;
 290
 291         char* szGetMediaUri = NULL;
 292         MpUtilVolumeTypeSet();
 293
 294         if(!pAppSvcHandle)
 295         {
 296                 VideoLogInfo("[ERR] No exist pBundle.");
 297                 bIsForeground = FALSE;
 298                 MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 299                 return;
 300         }
 301
 302         if(pAppData->pMainWindow == NULL)
 303         {
 304                 VideoLogInfo("Create main window.");
 305                 pAppData->pMainWindow = (Evas_Object *)MpUtilCreateMainWindow(PACKAGE);
 306         }
 307         else
 308         {
 309                 if(strlen(pAppData->szMediaUri) > 0)
 310                 {
 311                         MpVideoAppCtrlResetForRelaunching(pAppData);
 312                 }
 313         }
 314
 315         if(MpVideoServiceCtrlInitServiceParser((void*)pAppSvcHandle, &szGetMediaUri) == MP_ERROR_PLAYER_TYPE)
 316         {
 317                 VideoLogInfo("[ERR] Fail to init service parser.");
 318                 bIsForeground = FALSE;
 319                 MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 320                 return;
 321         }
 322
 323         if(szGetMediaUri)
 324         {
 325                 strncpy(pAppData->szMediaUri, szGetMediaUri, STR_LEN_MAX);
 326                 VideoLogInfo("szGetMediaUri : %s", pAppData->szMediaUri);
 327                 free(szGetMediaUri);
 328         }
 329         else
 330         {
 331                 VideoLogInfo("No exist szGetMediaUri");
 332         }
 333
 334         if(!MpUtilBatteryStatusNoti(pAppData))
 335         {
 336                 VideoLogInfo("[ERR] Fail to set Battery notification.");
 337                 bIsForeground = FALSE;
 338                 MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 339                 return;
 340         }
 341         bIsForeground = TRUE;
 342
 343         MpUtilMediaSvcInitSession();
 344         MpUtilSetKeyGrab(HOME_KEY, KEY_GRAB_SHARED);
 345         MpVideoAppCtrlInit(pAppData);
 346 }
 347
 348 static void appExit(void *pUserData)
 349 {
 350         VideoLogInfo("");
 351
 352         if (!pUserData) {
 353                 VideoLogInfo("[ERR] No exist pUserData.");
 354                 return;
 355         }
 356         VideoAppData *pAppData = (VideoAppData *)pUserData;
 357
 358         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 359
 360         MpUtilMultimediaVolumeKeyUngrab();
 361         MpUtilLcdOffForPowerButton();
 362         MpUtilSetKeyUngrab(HOME_KEY);
 363         MpUtilMultimediaKeyUngrab();
 364         MpUtilMMCstatusNotiIgnore();
 365         MpUtilBatteryStatusNotiIgnore();
 366         MpUtilVolumeTypeUnset();
 367         MpUtilFinishSession();
 368         MpUtilDeletePopupHandle();
 369         MpUtilMediaSvcDestoryVideoList();
 370         MpUtilMediaSvcFinishSession();
 371
 372         _mp_free_service_value(pUserData);
 373
 374         bIsForeground = FALSE;
 375         MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 376
 377 #ifdef TA_SVAE_PERF_FILE
 378         VP_PERF_DEINIT();
 379 #endif
 380 }
 381
 382 static void appPause(void *pUserData)
 383 {
 384         if(!pUserData)
 385         {
 386                 VideoLogInfo("No exist pUserdata handle.");
 387                 return;
 388         }
 389
 390         VideoLogInfo("");
 391
 392         MpUtilVolumeTypeUnset();
 393         MpUtilMultimediaVolumeKeyUngrab();
 394
 395         VideoAppData *pAppData = (VideoAppData *)pUserData;
 396
 397         if(MpVideoAppCtrlIsCheckCallStatus())
 398         {
 399                 VideoLogInfo("Skip for Call Pause.");
 400                 MpVideoAppCtrlInitCheckCallStatus();
 401         }
 402
 403         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
 404
 405         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
 406                         nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
 407                         nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
 408                         nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
 409                         nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
 410         {
 411                 VideoLogInfo("Pause application at video player.");
 412                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 413         }
 414         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
 415         {
 416                 VideoLogInfo("Pause application at streaming player.");
 417                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 418         }
 419
 420         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlHideLayout(pAppData);
 421
 422         MpUtilDeletePopupHandle();
 423
 424         elm_win_indicator_mode_set(pAppData->pMainWindow, ELM_WIN_INDICATOR_SHOW);
 425
 426         bIsForeground = FALSE;
 427         MpVideoAppCtrlSetForCheckingForegroundwindow(FALSE);
 428
 429         evas_object_hide(pAppData->pMainWindow);
 430 }
 431
 432 static void appResume(void *pUserData)
 433 {
 434         if(!pUserData)
 435         {
 436                 VideoLogInfo("No exist pUserdata handle.");
 437                 return;
 438         }
 439
 440         VideoLogInfo("");
 441
 442         VideoAppData *pAppData = (VideoAppData *)pUserData;
 443
 444         if(bIsForeground)
 445         {
 446                 VideoLogInfo("Defence overlap launching.");
 447                 return;
 448         }
 449         MpUtilVolumeTypeSet();
 450
 451         MpUtilMultimediaVolumeKeyGrab();
 452
 453         if(!MpVideoAppCtrlIsTopView(pUserData))
 454         {
 455                 VideoLogError("Overlay is not staied in top.");
 456                 return;
 457         }
 458
 459         if(MpVideoAppCtrlIsExistPlayerHandle())
 460         {
 461                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlResume(pAppData);
 462         }
 463         else
 464         {
 465                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStartByAppResume(pAppData);
 466         }
 467
 468         elm_win_indicator_mode_set(pAppData->pMainWindow, ELM_WIN_INDICATOR_SHOW);
 469
 470         bIsForeground = TRUE;
 471         MpVideoAppCtrlSetForCheckingForegroundwindow(TRUE);
 472
 473         evas_object_show(pAppData->pMainWindow);
 474 }
 475
 476 static void appRotate(app_device_orientation_e rotateState, void *pUserData)
 477 {
 478         VideoLogInfo("");
 479
 480         int nCurRotate = 0;
 481
 482         switch(rotateState)
 483         {
 484         case APP_DEVICE_ORIENTATION_0:
 485                 VideoLogInfo("VIDEO_ROTATE_PORTRAIT_NORMAL");
 486                 nCurRotate = VIDEO_ROTATE_PORTRAIT_NORMAL;
 487                 break;
 488
 489         case APP_DEVICE_ORIENTATION_90:
 490                 VideoLogInfo("VIDEO_ROTATE_LANDSCAPE_REVERSE");
 491                 nCurRotate = VIDEO_ROTATE_LANDSCAPE_REVERSE;
 492                 break;
 493
 494         case APP_DEVICE_ORIENTATION_180:
 495                 VideoLogInfo("VIDEO_ROTATE_PORTRAIT_REVERSE");
 496                 nCurRotate = VIDEO_ROTATE_PORTRAIT_REVERSE;
 497                 break;
 498
 499         case APP_DEVICE_ORIENTATION_270:
 500                 VideoLogInfo("VIDEO_ROTATE_LANDSCAPE_NORMAL");
 501                 nCurRotate = VIDEO_ROTATE_LANDSCAPE_NORMAL;
 502                 break;
 503         }
 504
 505         MpVideoAppCtrlSetRotation(nCurRotate, pUserData);
 506 }
 507
 508 int main(int argc, char *argv[])
 509 {
 510         VideoAppData pAppData;
 511         memset(&pAppData, 0, sizeof(VideoAppData));
 512
 513         app_event_callback_s st_appEventService;
 514
 515         st_appEventService.create = appCreate;
 516         st_appEventService.terminate = appExit;
 517         st_appEventService.pause = appPause;
 518         st_appEventService.resume = appResume;
 519         st_appEventService.service = appService;
 520         st_appEventService.low_memory = NULL;
 521         st_appEventService.low_battery = NULL;
 522         st_appEventService.device_orientation = appRotate;
 523         st_appEventService.language_changed = NULL;
 524         st_appEventService.region_format_changed = NULL;
 525
 526         if(app_efl_main(&argc, &argv, &st_appEventService, &pAppData) != APP_ERROR_NONE)
 527         {
 528                 VideoLogInfo("[ERR] app_efl_main().");
 529                 return -1;
 530         }
 531
 532         VideoLogInfo("escape app_efl_main() loop.");
 533
 534         return 0;
 535 }