src/mp-video-app-ctrl.c

   1 /*
   2  * Copyright   2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * This file is part of org.tizen.video-player
   5  * Written by  JongDong Lee <jongdong.lee@samsung.com>, ChangSun Lee <cs78.lee@samsung.com>
   6  *
   7  * PROPRIETARY/CONFIDENTIAL
   8  *
   9  * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
  10  * You shall not disclose such Confidential Information and shall
  11  * use it only in accordance with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
  12  * SAMSUNG make no representations or warranties about the suitability
  13  * of the software, either express or implied, including but not
  14  * limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement.
  15  * SAMSUNG shall not be liable for any damages suffered by licensee as
  16  * a result of using, modifying or distributing this software or its derivatives.
  17  *
  18  */
  19
  20
  21
  22
  23 #include <mm_error.h>
  24 #include <mm_message.h>
  25
  26 #include "mp-util.h"
  27 #include "mp-video-log.h"
  28 #include "mp-video-app-ctrl.h"
  29 #include "mp-video-view-ctrl.h"
  30 #include "mp-util-media-service.h"
  31 #include "mp-video-value-define.h"
  32 #include "mp-video-subtitle-ctrl.h"
  33 #include "mp-video-string-define.h"
  34 #include "mp-video-streaming-ctrl.h"
  35
  36 #include "mp-video-ctrl-mgr.h"
  37
  38 static int nBufferingRate = 0;
  39 static double nDurationTime = 0;
  40 static char szSubtitleString[STR_LEN_MAX] = {0};
  41 static int nErrorCode = 0;
  42
  43 static Ecore_Pipe       *pEcorePipeHandleForErrorMsg = NULL;
  44 static Ecore_Pipe       *pEcorePipeHandleBOF = NULL;
  45 static Ecore_Pipe       *pEcorePipeHandleEOF = NULL;
  46 static Ecore_Pipe       *pEcorePipeHandleForBuffering = NULL;
  47 static Ecore_Pipe       *pEcorePipeHandleForBluetooth = NULL;
  48 static Ecore_Pipe       *pEcorePipeHandleForSubTitle = NULL;
  49 static Ecore_Pipe       *pEcorePipeHandleForResumed = NULL;
  50 static Ecore_Pipe       *pEcorePipeHandleForInterruped = NULL;
  51
  52 static void MpVideoAppCtrlStart(VideoAppData *pAppData);
  53 static void MpVideoAppCtrlStop(VideoAppData *pAppData);
  54 static void MpVideoAppCtrlPause(VideoAppData *pAppData);
  55 static void MpVideoAppCtrlResume(VideoAppData *pAppData);
  56 static void MpVideoAppCtrlStopByAppPause(VideoAppData *pAppData);
  57 static void MpVideoAppCtrlStartByAppResume(VideoAppData *pAppData);
  58 static void MpVideoAppCtrlFFDown(VideoAppData *pAppData);
  59 static void MpVideoAppCtrlRewDown(VideoAppData *pAppData);
  60 static void MpVideoAppCtrlFFUp(VideoAppData *pAppData);
  61 static void MpVideoAppCtrlRewUp(VideoAppData *pAppData);
  62 static void MpVideoAppCtrlSetMute(VideoAppData *pAppData);
  63 static void MpVideoAppCtrlSetScreenType(VideoAppData *pAppData);
  64 static void MpVideoAppCtrlSetScreenSize(VideoAppData *pAppData, int nScreenSize);
  65 static void MpVideoAppCtrlGetPosition(VideoAppData *pAppData);
  66 static void MpVideoAppCtrlSetPosition(VideoAppData *pAppData);
  67 static void MpVideoAppCtrlHideLayout(VideoAppData *pAppData);
  68 static void MpVideoAppCtrlShowLayout(VideoAppData *pAppData);
  69 static void MpVideoAppCtrlGetVideoResolution(VideoAppData *pAppData);
  70 static void MpVideoAppCtrlReqDurationTime(VideoAppData *pAppData);
  71 static void MpVideoAppCtrlBeginOfStream(VideoAppData *pAppData);
  72 static void MpVideoAppCtrlEndOfStream(VideoAppData *pAppData);
  73 static void MpVideoAppCtrlExit(VideoAppData *pAppData);
  74 static void MpVideoAppCtrlStartStreaming(VideoAppData *pAppData);
  75 static void MpVideoAppCtrlReLaunching(VideoAppData *pAppData);
  76 static void MpVideoAppCtrlPlayPreMedia(VideoAppData *pAppData);
  77 static void MpVideoAppCtrlPlayNextMedia(VideoAppData *pAppData);
  78 static void MpVideoAppCtrlGetBufferingPosition(VideoAppData *pAppData);
  79 static void MpVideoAppCtrlErrorMsg(VideoAppData *pAppData, unsigned int nErrorCode);
  80 static void MpVideoAppCtrlPipeInit(VideoAppData *pAppData);
  81
  82
  83 /*
  84  * Callback function
  85  */
  86 static void MpVideoAppCtrlWarningPopupCb(void *pUserData, Evas_Object *pObject,
  87                                          void *pEventInfo)
  88 {
  89         if (!pUserData) {
  90                 VideoLogInfo("No exist pUserData");
  91                 return;
  92         }
  93
  94         VideoLogInfo("");
  95
  96         MpUtilDeletePopupHandle();
  97 }
  98
  99 static void MpVideoAppCtrlExitCb(void *pUserData, Evas_Object *pObject,
 100                                  void *pEventInfo)
 101 {
 102         if (!pUserData) {
 103                 VideoLogInfo("No exist pUserData");
 104                 return;
 105         }
 106
 107         VideoLogInfo("");
 108
 109         VideoAppData *pAppData = (VideoAppData *)pUserData;
 110
 111         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 112 }
 113
 114 static int MpVideoAppCtrlPauseByInterrupteCb(void *pUserData)
 115 {
 116         if (!pUserData) {
 117                 VideoLogInfo("No exist pUserData");
 118                 return 0;
 119         }
 120
 121         VideoLogInfo("");
 122
 123         VideoAppData *pAppData = (VideoAppData *)pUserData;
 124
 125         MpVideoViewHideSoundpath(pUserData);
 126         MpVideoAppCtrlPause(pAppData);
 127
 128         return 0;
 129 }
 130
 131 static int MpVideoAppCtrlBeginOfPlayCb(void *pUserData)
 132 {
 133         if (!pUserData) {
 134                 VideoLogInfo("No exist pUserData");
 135                 return 0;
 136         }
 137
 138         VideoLogInfo("");
 139
 140         VideoAppData *pAppData = (VideoAppData *)pUserData;
 141
 142         MpVideoAppCtrlSetMute(pAppData);
 143         MpVideoAppCtrlBeginOfStream(pAppData);
 144
 145         return 0;
 146 }
 147
 148 static int MpVideoAppCtrlEndOfPlayCb(void *pUserData)
 149 {
 150         if (!pUserData) {
 151                 VideoLogInfo("No exist pUserData");
 152                 return 0;
 153         }
 154
 155         VideoLogInfo("");
 156
 157         VideoAppData *pAppData = (VideoAppData *)pUserData;
 158         MpVideoAppCtrlEndOfStream(pAppData);
 159
 160         return 0;
 161 }
 162
 163 static int MpVideoAppCtrlBufferingCb(void *pUserData)
 164 {
 165         if (!pUserData) {
 166                 VideoLogInfo("No exist pUserData");
 167                 return 0;
 168         }
 169
 170         VideoLogInfo("");
 171
 172         MpVideoViewSetBufferingRateForStreamingView(nBufferingRate, pUserData);
 173
 174         return 0;
 175 }
 176
 177 static int MpVideoAppCtrlBluetoothCb(void *pUserData)
 178 {
 179         if (!pUserData) {
 180                 VideoLogInfo("No exist pUserData");
 181                 return 0;
 182         }
 183
 184         VideoLogInfo("");
 185
 186         return 0;
 187 }
 188
 189 static int MpVideoAppCtrlResumeByRewCb(void *pUserData)
 190 {
 191         if (!pUserData) {
 192                 VideoLogInfo("No exist pUserData");
 193                 return 0;
 194         }
 195
 196         VideoLogInfo("");
 197
 198         VideoAppData *pAppData = (VideoAppData *)pUserData;
 199
 200         MpVideoAppCtrlResume(pAppData);
 201
 202         return 0;
 203 }
 204
 205 static Eina_Bool MpVideoAppCtrlUpdateSubtitleCb(void* pUserData)
 206 {
 207         if (!pUserData) {
 208                 VideoLogInfo("No exist pUserData");
 209                 return EINA_FALSE;
 210         }
 211
 212         VideoLogInfo("");
 213
 214         if (strlen(szSubtitleString) > 0 && nDurationTime > 0) {
 215                 MpVideoViewCtrlUpdateSubtitle(nDurationTime, szSubtitleString);
 216         }
 217
 218         return EINA_FALSE;
 219 }
 220
 221 static int MpVideoAppCtrlMmfErrormsgCb(void *pUserData)
 222 {
 223         if (!pUserData) {
 224                 VideoLogInfo("No exist pUserData");
 225                 return 0;
 226         }
 227
 228         VideoLogInfo("");
 229
 230         VideoAppData *pAppData = (VideoAppData *)pUserData;
 231
 232         MpVideoAppCtrlErrorMsg(pAppData, nErrorCode);
 233
 234         return 0;
 235 }
 236
 237 static void MpVideoAppCtrlErrorMsg(VideoAppData *pAppData,
 238                                    unsigned int nErrorCode)
 239 {
 240         VideoLogInfo("[MMF ERROR] CtrlErrorMsg.");
 241
 242         switch (nErrorCode) {
 243         case 1:
 244                 VideoLogInfo("Connection Fail.");
 245                 break;
 246
 247         case MM_ERROR_PLAYER_CODEC_NOT_FOUND:
 248                 VideoLogInfo("CODEC NOT FOUND");
 249                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_POP_UNSUPPORTED_FILE_TYPE),
 250                                   MpVideoAppCtrlExitCb);
 251                 break;
 252
 253         case MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND:
 254                 VideoLogInfo("UNSUPPORTED_AUDIO_FORMAT");
 255                 MpUtilNotifyPopUp(pAppData,
 256                                   _(MP_VPL_POP_UNSUPPORTED_AUDIO_FORMAT),
 257                                   MpVideoAppCtrlWarningPopupCb);
 258                 break;
 259
 260         case MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND:
 261                 VideoLogInfo("UNSUPPORTED_VIDEO_FORMAT");
 262                 MpVideoViewCtrlShowNocontentImage();
 263                 MpUtilNotifyPopUp(pAppData,
 264                                   _(MP_VPL_POP_UNSUPPORTED_VIDEO_FORMAT),
 265                                   MpVideoAppCtrlWarningPopupCb);
 266                 break;
 267
 268         case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_AUDIO:
 269                 VideoLogInfo("UNSUPPORTED_AUDIO_FORMAT");
 270                 MpUtilNotifyPopUp(pAppData,
 271                                   _(MP_VPL_POP_UNSUPPORTED_AUDIO_FORMAT),
 272                                   MpVideoAppCtrlWarningPopupCb);
 273                 break;
 274
 275         case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_VIDEO:
 276                 VideoLogInfo("UNSUPPORTED_VIDEO_FORMAT");
 277                 MpVideoViewCtrlShowNocontentImage();
 278                 MpUtilNotifyPopUp(pAppData,
 279                                   _(MP_VPL_POP_UNSUPPORTED_VIDEO_FORMAT),
 280                                   MpVideoAppCtrlWarningPopupCb);
 281                 break;
 282
 283         case MM_ERROR_PLAYER_STREAMING_CONNECTION_FAIL:
 284                 VideoLogInfo("CONNECTION_FAILED");
 285                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 286                                   MpVideoAppCtrlExitCb);
 287                 break;
 288
 289         case MM_ERROR_PLAYER_INVALID_STREAM:
 290                 VideoLogInfo("MM_ERROR_PLAYER_INVALID_STREAM");
 291                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_UNABLE_TO_PLAY_VIDEO),
 292                                   MpVideoAppCtrlExitCb);
 293                 break;
 294
 295         case MM_ERROR_PLAYER_FILE_NOT_FOUND:
 296                 VideoLogInfo("MM_ERROR_PLAYER_FILE_NOT_FOUND");
 297                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_POP_INVALID_STREAMING_DATA),
 298                                   MpVideoAppCtrlExitCb);
 299                 break;
 300
 301         case MM_ERROR_PLAYER_STREAMING_DNS_FAIL:
 302                 VideoLogInfo("DNS_FAILED");
 303                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 304                                   MpVideoAppCtrlExitCb);
 305                 break;
 306
 307         case MM_ERROR_PLAYER_STREAMING_SERVER_DISCONNECTED:
 308                 VideoLogInfo("DESCONNECTED_FROM_SERVER");
 309                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 310                                   MpVideoAppCtrlExitCb);
 311                 break;
 312
 313         case MM_ERROR_PLAYER_STREAMING_BAD_SERVER:
 314                 VideoLogInfo("UNABLE_TO_PLAY_INVALID_PACKET_FROM_SERVER");
 315                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 316                                   MpVideoAppCtrlExitCb);
 317                 break;
 318
 319         case MM_ERROR_PLAYER_STREAMING_INVALID_PROTOCOL:
 320                 VideoLogInfo("UNSUPPORTED_TRANSPORT_PROTOCOL");
 321                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 322                                   MpVideoAppCtrlExitCb);
 323                 break;
 324
 325         case MM_ERROR_PLAYER_STREAMING_INVALID_URL:
 326                 VideoLogInfo("INVALID_URL");
 327                 MpUtilNotifyPopUp(pAppData,
 328                                   _(MP_VPL_POP_INVALID_STREAMING_DATA),
 329                                   MpVideoAppCtrlExitCb);
 330                 break;
 331
 332         case MM_ERROR_PLAYER_STREAMING_UNEXPECTED_MSG:
 333                 VideoLogInfo("UNEXPECTED_MESSAGE");
 334                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 335                                   MpVideoAppCtrlExitCb);
 336                 break;
 337
 338         case MM_ERROR_PLAYER_STREAMING_OUT_OF_MEMORIES:
 339                 VideoLogInfo("OUT_OF_MEMORIES");
 340                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 341                                   MpVideoAppCtrlExitCb);
 342                 break;
 343
 344         case MM_ERROR_PLAYER_STREAMING_RTSP_TIMEOUT:
 345                 VideoLogInfo("NO_RESPONSE_FROM_SERVER");
 346                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 347                                   MpVideoAppCtrlExitCb);
 348                 break;
 349
 350         case MM_ERROR_PLAYER_STREAMING_BAD_REQUEST:
 351                 VideoLogInfo("BAD_REQUEST");
 352                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 353                                   MpVideoAppCtrlExitCb);
 354                 break;
 355
 356         case MM_ERROR_PLAYER_STREAMING_NOT_AUTHORIZED:
 357                 VideoLogInfo("NOT_AUTHORIZED");
 358                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 359                                   MpVideoAppCtrlExitCb);
 360                 break;
 361
 362         case MM_ERROR_PLAYER_STREAMING_PAYMENT_REQUIRED:
 363                 VideoLogInfo("PAYMENT_REQUIRED");
 364                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 365                                   MpVideoAppCtrlExitCb);
 366                 break;
 367
 368         case MM_ERROR_PLAYER_STREAMING_FORBIDDEN:
 369                 VideoLogInfo("FORBIDDEN");
 370                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 371                                   MpVideoAppCtrlExitCb);
 372                 break;
 373
 374         case MM_ERROR_PLAYER_STREAMING_CONTENT_NOT_FOUND:
 375                 VideoLogInfo("CONTENT_NOT_FOUND");
 376                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 377                                   MpVideoAppCtrlExitCb);
 378                 break;
 379
 380         case MM_ERROR_PLAYER_STREAMING_METHOD_NOT_ALLOWED:
 381                 VideoLogInfo("METHOD_NOT_ALLOWED");
 382                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 383                                   MpVideoAppCtrlExitCb);
 384                 break;
 385
 386         case MM_ERROR_PLAYER_STREAMING_NOT_ACCEPTABLE:
 387                 VideoLogInfo("NOT_ACCEPTABLE");
 388                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 389                                   MpVideoAppCtrlExitCb);
 390                 break;
 391
 392         case MM_ERROR_PLAYER_STREAMING_PROXY_AUTHENTICATION_REQUIRED:
 393                 VideoLogInfo("PROXY_AUTHENTICATION_REQUIRED");
 394                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 395                                   MpVideoAppCtrlExitCb);
 396                 break;
 397
 398         case MM_ERROR_PLAYER_STREAMING_SERVER_TIMEOUT:
 399                 VideoLogInfo("SERVER_TIMEOUT");
 400                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 401                                   MpVideoAppCtrlExitCb);
 402                 break;
 403
 404         case MM_ERROR_PLAYER_STREAMING_GONE:
 405                 VideoLogInfo("GONE_MERROR");
 406                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 407                                   MpVideoAppCtrlExitCb);
 408                 break;
 409
 410         case MM_ERROR_PLAYER_STREAMING_LENGTH_REQUIRED:
 411                 VideoLogInfo("LENGTH_REQUIRED");
 412                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 413                                   MpVideoAppCtrlExitCb);
 414                 break;
 415
 416         case MM_ERROR_PLAYER_STREAMING_PRECONDITION_FAILED:
 417                 VideoLogInfo("PRECONDITION_FAILED");
 418                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 419                                   MpVideoAppCtrlExitCb);
 420                 break;
 421
 422         case MM_ERROR_PLAYER_STREAMING_REQUEST_ENTITY_TOO_LARGE:
 423                 VideoLogInfo("REQUEST_ENTITY_TOO_LARGE");
 424                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 425                                   MpVideoAppCtrlExitCb);
 426                 break;
 427
 428         case MM_ERROR_PLAYER_STREAMING_REQUEST_URI_TOO_LARGE:
 429                 VideoLogInfo("REQUEST_URI_TOO_LARGE");
 430                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 431                                   MpVideoAppCtrlExitCb);
 432                 break;
 433
 434         case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_MEDIA_TYPE:
 435                 VideoLogInfo("UNSUPPORTED_MEDIA_TYPE");
 436                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_UNABLE_TO_PLAY_VIDEO),
 437                                   MpVideoAppCtrlExitCb);
 438                 break;
 439
 440         case MM_ERROR_PLAYER_STREAMING_PARAMETER_NOT_UNDERSTOOD:
 441                 VideoLogInfo("PARAMETER_NOT_UNDERSTOOD");
 442                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 443                                   MpVideoAppCtrlExitCb);
 444                 break;
 445
 446         case MM_ERROR_PLAYER_STREAMING_CONFERENCE_NOT_FOUND:
 447                 VideoLogInfo("CONFERENCE_NOT_FOUND");
 448                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 449                                   MpVideoAppCtrlExitCb);
 450                 break;
 451
 452         case MM_ERROR_PLAYER_STREAMING_NOT_ENOUGH_BANDWIDTH:
 453                 VideoLogInfo("NOT_ENOUGH_BANDWIDTH");
 454                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 455                                   MpVideoAppCtrlExitCb);
 456                 break;
 457
 458         case MM_ERROR_PLAYER_STREAMING_NO_SESSION_ID:
 459                 VideoLogInfo("NO_SESSION_ID");
 460                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 461                                   MpVideoAppCtrlExitCb);
 462                 break;
 463
 464         case MM_ERROR_PLAYER_STREAMING_METHOD_NOT_VALID_IN_THIS_STATE:
 465                 VideoLogInfo("METHOD_NOT_VALID_IN_THIS_STATE");
 466                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 467                                   MpVideoAppCtrlExitCb);
 468                 break;
 469
 470         case MM_ERROR_PLAYER_STREAMING_HEADER_FIELD_NOT_VALID_FOR_SOURCE:
 471                 VideoLogInfo("HEADER_FIELD_NOT_VALID_FOR_SOURCE");
 472                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 473                                   MpVideoAppCtrlExitCb);
 474                 break;
 475
 476         case MM_ERROR_PLAYER_STREAMING_INVALID_RANGE:
 477                 VideoLogInfo("INVALID_RANGE");
 478                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 479                                   MpVideoAppCtrlExitCb);
 480                 break;
 481
 482         case MM_ERROR_PLAYER_STREAMING_PARAMETER_IS_READONLY:
 483                 VideoLogInfo("PARAMETER_IS_READONLY");
 484                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 485                                   MpVideoAppCtrlExitCb);
 486                 break;
 487
 488         case MM_ERROR_PLAYER_STREAMING_AGGREGATE_OP_NOT_ALLOWED:
 489                 VideoLogInfo("AGGREGATE_OP_NOT_ALLOWED");
 490                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 491                                   MpVideoAppCtrlExitCb);
 492                 break;
 493
 494         case MM_ERROR_PLAYER_STREAMING_ONLY_AGGREGATE_OP_ALLOWED:
 495                 VideoLogInfo("ONLY_AGGREGATE_OP_ALLOWED");
 496                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 497                                   MpVideoAppCtrlExitCb);
 498                 break;
 499
 500         case MM_ERROR_PLAYER_STREAMING_BAD_TRANSPORT:
 501                 VideoLogInfo("BAD_TRANSPORT");
 502                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 503                                   MpVideoAppCtrlExitCb);
 504                 break;
 505
 506         case MM_ERROR_PLAYER_STREAMING_DESTINATION_UNREACHABLE:
 507                 VideoLogInfo("DESTINATION_UNREACHABLE");
 508                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 509                                   MpVideoAppCtrlExitCb);
 510                 break;
 511
 512         case MM_ERROR_PLAYER_STREAMING_INTERNAL_SERVER_ERROR:
 513                 VideoLogInfo("INTERNAL_SERVER_ERROR");
 514                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 515                                   MpVideoAppCtrlExitCb);
 516                 break;
 517
 518         case MM_ERROR_PLAYER_STREAMING_NOT_IMPLEMENTED:
 519                 VideoLogInfo("NOT_IMPLEMENTED");
 520                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 521                                   MpVideoAppCtrlExitCb);
 522                 break;
 523
 524         case MM_ERROR_PLAYER_STREAMING_BAD_GATEWAY:
 525                 VideoLogInfo("BAD_GATEWAY");
 526                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 527                                   MpVideoAppCtrlExitCb);
 528                 break;
 529
 530         case MM_ERROR_PLAYER_STREAMING_SERVICE_UNAVAILABLE:
 531                 VideoLogInfo("SERVICE_UNAVAILABLE");
 532                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 533                                   MpVideoAppCtrlExitCb);
 534                 break;
 535
 536         case MM_ERROR_PLAYER_STREAMING_GATEWAY_TIME_OUT:
 537                 VideoLogInfo("GATEWAY_TIME_OUT");
 538                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 539                                   MpVideoAppCtrlExitCb);
 540                 break;
 541
 542         case MM_ERROR_PLAYER_STREAMING_RTSP_VERSION_NOT_SUPPORTED:
 543                 VideoLogInfo("RTSP_VERSION_NOT_SUPPORTED");
 544                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 545                                   MpVideoAppCtrlExitCb);
 546                 break;
 547
 548         case MM_ERROR_PLAYER_STREAMING_OPTION_NOT_SUPPORTED:
 549                 VideoLogInfo("OPTION_NOT_SUPPORTED");
 550                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_CONNECTION_FAIL),
 551                                   MpVideoAppCtrlExitCb);
 552                 break;
 553
 554         case MM_ERROR_PLAYER_STREAMING_FAIL:
 555                 VideoLogInfo("INTERNAL_ERROR");
 556                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_UNABLE_TO_PLAY_VIDEO),
 557                                   MpVideoAppCtrlExitCb);
 558                 break;
 559         case MM_MESSAGE_DRM_NOT_AUTHORIZED :
 560                 VideoLogInfo("DRM_NOT_AUTHORIZED ERROR");
 561                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_UNABLE_TO_PLAY_VIDEO),
 562                                   MpVideoAppCtrlExitCb);
 563                 break;
 564
 565         default:
 566                 break;
 567         }
 568
 569  }
 570
 571 static void MpVideoAppCtrlPlayerMsgCallback(int MessageType,
 572                                             void *MessageParam, void *pUserData)
 573 {
 574         if (!pUserData) {
 575                 VideoLogInfo("[ERR]");
 576                 return;
 577         }
 578
 579         VideoLogInfoWithTid("Callback func");
 580
 581         VideoAppData *pAppData = (VideoAppData *)pUserData;
 582         MMMessageParamType *pParam = (MMMessageParamType *) MessageParam;
 583
 584         switch (MessageType) {
 585         case MM_MESSAGE_UNKNOWN:
 586                 VideoLogInfo("MM_MESSAGE_UNKNOWN", MessageType);
 587                 if(pEcorePipeHandleForErrorMsg) {
 588                         if(!ecore_pipe_write(pEcorePipeHandleForErrorMsg,
 589                                         (void *)pAppData, sizeof(pAppData))) {
 590                                 VideoLogDebug("FAIL PIPE WRITE");
 591                         }
 592                 }
 593
 594                 break;
 595
 596         case MM_MESSAGE_ERROR:
 597                 VideoLogInfo("[ERR]MM_MESSAGE_ERROR : code-0x%x",
 598                              (int)pParam->code);
 599                 nErrorCode = (int)pParam->code;
 600                 if(pEcorePipeHandleForErrorMsg) {
 601                         if(!ecore_pipe_write(pEcorePipeHandleForErrorMsg,
 602                                         (void *)pAppData, sizeof(pAppData))) {
 603                                 VideoLogDebug("FAIL PIPE WRITE");
 604                         }
 605                 }
 606                 break;
 607
 608         case MM_MESSAGE_STATE_CHANGED:
 609                 VideoLogInfo("MM_MESSAGE_STATE_CHANGED");
 610                 break;
 611
 612         case MM_MESSAGE_BEGIN_OF_STREAM:
 613                 VideoLogInfo("MM_MESSAGE_BEGIN_OF_STREAM");
 614                 if(pEcorePipeHandleBOF) {
 615                         if(!ecore_pipe_write(pEcorePipeHandleBOF,
 616                                         (void *)pAppData, sizeof(pAppData))) {
 617                                 VideoLogDebug("FAIL PIPE WRITE");
 618                         }
 619                 }
 620                 break;
 621
 622         case MM_MESSAGE_END_OF_STREAM:
 623                 VideoLogInfo("END OF STREAM.");
 624                 if(pEcorePipeHandleEOF) {
 625                         if(!ecore_pipe_write(pEcorePipeHandleEOF,
 626                                         (void *)pAppData, sizeof(pAppData))) {
 627                                 VideoLogDebug("FAIL PIPE WRITE");
 628                         }
 629                 }
 630                 break;
 631
 632         case MM_MESSAGE_READY_TO_RESUME:
 633                 VideoLogInfo("MM_MESSAGE_READY_TO_RESUME");
 634                 break;
 635
 636         case MM_MESSAGE_CONNECTING:
 637                 VideoLogInfo("MM_MESSAGE_CONNECTING");
 638                 break;
 639
 640         case MM_MESSAGE_CONNECTED:
 641                 VideoLogInfo("MM_MESSAGE_CONNECTED");
 642                 break;
 643
 644         case MM_MESSAGE_CONNECTION_TIMEOUT:
 645                 VideoLogInfo("MM_MESSAGE_CONNECTION_TIMEOUT");
 646                 break;
 647
 648         case MM_MESSAGE_BUFFERING:
 649                 VideoLogInfo("MM_MESSAGE_BUFFERING - Buffering : %d%% ",
 650                              pParam->connection.buffering);
 651                 nBufferingRate = pParam->connection.buffering;
 652
 653                 if (nBufferingRate < 10)
 654                         MpVideoAppCtrlShowLayout(pAppData);
 655                 if(pEcorePipeHandleForBuffering) {
 656                         if(!ecore_pipe_write(pEcorePipeHandleForBuffering,
 657                                         (void *)pAppData, sizeof(pAppData))) {
 658                                 VideoLogDebug("FAIL PIPE WRITE");
 659                         }
 660                 }
 661                 break;
 662
 663         case MM_MESSAGE_BLUETOOTH_ON:
 664                 VideoLogInfo("MM_MESSAGE_BLUETOOTH_ON");
 665                 break;
 666
 667         case MM_MESSAGE_BLUETOOTH_OFF:
 668                 VideoLogInfo("MM_MESSAGE_BLUETOOTH_OFF ");
 669                 if(pEcorePipeHandleForBluetooth) {
 670                         if(!ecore_pipe_write(pEcorePipeHandleForBluetooth,
 671                                         (void *)pAppData, sizeof(pAppData))) {
 672                                 VideoLogDebug("FAIL PIPE WRITE");
 673                         }
 674                 }
 675                 break;
 676
 677         case MM_MESSAGE_UPDATE_SUBTITLE:
 678                 VideoLogInfo("UPDATE_SUBTITLE ");
 679
 680                 nDurationTime = 0;
 681                 memset(szSubtitleString, 0, sizeof(char) * STR_LEN_MAX);
 682
 683                 if (pParam->subtitle.duration <= 0) {
 684                         VideoLogInfo("[ERR] MMF Error : code-0x%x", (int)pParam->code);
 685                         break;
 686                 } else {
 687                                 nDurationTime = (double)pParam->subtitle.duration / 1000;
 688                 }
 689
 690                 if (pParam->data == NULL) {
 691                         VideoLogInfo("[ERR] MMF Error : code-0x%x", (int)pParam->code);
 692                         break;
 693                 } else {
 694                         strncpy(szSubtitleString, pParam->data, STR_LEN_MAX - 1);
 695                 }
 696
 697                 VideoLogInfo("Subtitle duration : %d sec", nDurationTime);
 698                 VideoLogInfo("Subtitle contents : %s", szSubtitleString);
 699                 if(pEcorePipeHandleForSubTitle) {
 700                         if(!ecore_pipe_write(pEcorePipeHandleForSubTitle,
 701                                         (void *)pAppData, sizeof(pAppData))) {
 702                                 VideoLogDebug("FAIL PIPE WRITE");
 703                         }
 704                 }
 705                 break;
 706
 707         case MM_MESSAGE_RESUMED_BY_REW:
 708                 VideoLogInfo("Change play state to play.");
 709                 if(pEcorePipeHandleForResumed) {
 710                         if(!ecore_pipe_write(pEcorePipeHandleForResumed,
 711                                         (void *)pAppData, sizeof(pAppData))) {
 712                                 VideoLogDebug("FAIL PIPE WRITE");
 713                         }
 714                 }
 715                 break;
 716
 717         case MM_MESSAGE_RTP_SENDER_REPORT:
 718                 VideoLogInfo("%08x", MessageType);
 719                 break;
 720
 721         case MM_MESSAGE_RTP_RECEIVER_REPORT:
 722                 VideoLogInfo("%08x", MessageType);
 723                 break;
 724
 725         case MM_MESSAGE_RTP_SESSION_STATUS:
 726                 VideoLogInfo("%08x", MessageType);
 727                 break;
 728
 729         case MM_MESSAGE_SENDER_STATE:
 730                 VideoLogInfo("%08x", MessageType);
 731                 break;
 732
 733         case MM_MESSAGE_RECEIVER_STATE:
 734                 VideoLogInfo("%08x", MessageType);
 735                 break;
 736
 737         case MM_MESSAGE_FILE_NOT_SUPPORTED:
 738                 VideoLogInfo("%08x", MessageType);
 739                 break;
 740
 741         case MM_MESSAGE_FILE_NOT_FOUND:
 742                 VideoLogInfo("%08x", MessageType);
 743                 break;
 744
 745         case MM_MESSAGE_DRM_NOT_AUTHORIZED:
 746                 VideoLogInfo("%08x", MessageType);
 747                 break;
 748
 749         case MM_MESSAGE_STATE_INTERRUPTED:
 750                 VideoLogDebug("%08x", MessageType);
 751
 752                 switch ((int)pParam->code) {
 753                 case MM_MSG_CODE_INTERRUPTED_BY_OTHER_APP:
 754                         VideoLogInfo("MM_ERROR_PLAYER_BT_CONNECTION");
 755                         break;
 756
 757                 case MM_MSG_CODE_INTERRUPTED_BY_CALL_START:
 758                         VideoLogInfo("MM_MSG_CODE_INTERRUPTED_BY_CALL_START");
 759                         break;
 760
 761                 case MM_MSG_CODE_INTERRUPTED_BY_CALL_END:
 762                         VideoLogInfo("MM_MSG_CODE_INTERRUPTED_BY_CALL_END");
 763                         break;
 764
 765                 case MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG:
 766                         VideoLogInfo("MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG");
 767                         break;
 768
 769                 case MM_MSG_CODE_INTERRUPTED_BY_RESOURCE_CONFLICT:
 770                         VideoLogInfo
 771                             ("MM_MSG_CODE_INTERRUPTED_BY_RESOURCE_CONFLICT");
 772                         break;
 773
 774                 case MM_MSG_CODE_INTERRUPTED_BY_ALARM_START:
 775                         VideoLogInfo
 776                             ("MM_MSG_CODE_INTERRUPTED_BY_ALARM_START");
 777                         break;
 778
 779                 case MM_MSG_CODE_INTERRUPTED_BY_ALARM_END:
 780                         VideoLogInfo("MM_MSG_CODE_INTERRUPTED_BY_ALARM_END");
 781                         break;
 782                 }
 783                 if(pEcorePipeHandleForInterruped) {
 784                         if(!ecore_pipe_write(
 785                                 pEcorePipeHandleForInterruped,
 786                                 (void *)pAppData, sizeof(pAppData))) {
 787                                 VideoLogDebug("FAIL PIPE WRITE");
 788                         }
 789                 }
 790                 break;
 791         case MM_MESSAGE_SEEK_COMPLETED:
 792                 {
 793                         VideoLogInfo("MM_MESSAGE_SEEK_COMPLETED");
 794                         if(MpUtilCheckRTSPType(pAppData->szMediaUri)) {
 795                                 VideoLogInfo("RTSP SEEK Start");
 796                                 nBufferingRate = 100;
 797                                 MpVideoAppCtrlShowLayout(pAppData);
 798                                 if(pEcorePipeHandleForBuffering) {
 799                                         if(!ecore_pipe_write(pEcorePipeHandleForBuffering,
 800                                                         (void *)pAppData, sizeof(pAppData))) {
 801                                                 VideoLogDebug("FAIL PIPE WRITE");
 802                                         }
 803                                 }
 804
 805                         }
 806
 807                 }
 808                 break;
 809         default:
 810                 VideoLogInfo("No message %08x", MessageType);
 811                 break;
 812         }
 813 }
 814
 815 /*
 816  * Internal function
 817  */
 818 void MpVideoAppCtrlFuncInit(VideoAppData *pAppData)
 819 {
 820         VideoLogInfo("");
 821
 822         if (!pAppData) {
 823                 VideoLogInfo("[ERR]");
 824                 return;
 825         }
 826
 827         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStart =
 828             (void *)MpVideoAppCtrlStart;
 829         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStop =
 830             (void *)MpVideoAppCtrlStop;
 831         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPause =
 832             (void *)MpVideoAppCtrlPause;
 833         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlResume =
 834             (void *)MpVideoAppCtrlResume;
 835         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStopByAppPause =
 836             (void *)MpVideoAppCtrlStopByAppPause;
 837         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStartByAppResume =
 838             (void *)MpVideoAppCtrlStartByAppResume;
 839         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlFFDown =
 840             (void *)MpVideoAppCtrlFFDown;
 841         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlRewDown =
 842             (void *)MpVideoAppCtrlRewDown;
 843         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlFFUp =
 844             (void *)MpVideoAppCtrlFFUp;
 845         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlRewUp =
 846             (void *)MpVideoAppCtrlRewUp;
 847         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetMute =
 848             (void *)MpVideoAppCtrlSetMute;
 849         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetScreenType =
 850             (void *)MpVideoAppCtrlSetScreenType;
 851         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetScreenSize =
 852             (void *)MpVideoAppCtrlSetScreenSize;
 853         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlGetPosition =
 854             (void *)MpVideoAppCtrlGetPosition;
 855         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetPosition =
 856             (void *)MpVideoAppCtrlSetPosition;
 857         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlHideLayout =
 858             (void *)MpVideoAppCtrlHideLayout;
 859         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlShowLayout =
 860             (void *)MpVideoAppCtrlShowLayout;
 861         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlGetVideoResolution =
 862             (void *)MpVideoAppCtrlGetVideoResolution;
 863         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlReqDurationTime =
 864             (void *)MpVideoAppCtrlReqDurationTime;
 865         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlBeginOfStream =
 866             (void *)MpVideoAppCtrlBeginOfStream;
 867         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlEndOfStream =
 868             (void *)MpVideoAppCtrlEndOfStream;
 869         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit =
 870             (void *)MpVideoAppCtrlExit;
 871         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStartStreaming =
 872             (void *)MpVideoAppCtrlStartStreaming;
 873         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlReLaunching =
 874             (void *)MpVideoAppCtrlReLaunching;
 875         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPlayPreMedia =
 876             (void *)MpVideoAppCtrlPlayPreMedia;
 877         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPlayNextMedia =
 878             (void *)MpVideoAppCtrlPlayNextMedia;
 879         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlGetBufferingPosition =
 880             (void *)MpVideoAppCtrlGetBufferingPosition;
 881 }
 882
 883 static void MpVideoAppCtrlPlayPreMedia(VideoAppData *pAppData)
 884 {
 885         if (!pAppData) {
 886                 VideoLogInfo("No exist appdata.");
 887                 return;
 888         }
 889
 890         VideoLogInfo("");
 891
 892         if (strlen(pAppData->szPreMediaUri) <= 0) {
 893                 VideoLogInfo("szPreMediaUri is NULL.");
 894                 return;
 895         }
 896
 897         VideoLogInfo("Current media uri : %s", pAppData->szMediaUri);
 898         VideoLogInfo("Previous media uri : %s", pAppData->szPreMediaUri);
 899
 900         strncpy(pAppData->szMediaUri, pAppData->szPreMediaUri,
 901                 sizeof(pAppData->szMediaUri) - 1);
 902         MpVideoAppCtrlShowLayout(pAppData);
 903
 904         if (pAppData->nCurPlayerType == MP_VIDEO_PLAYER) {
 905                 MpUtilMediaSvcGetPreNextVideoUrl(pAppData->szMediaUri,
 906                                                  pAppData->szPreMediaUri,
 907                                                  pAppData->szNextMediaUri);
 908         }
 909
 910         MpVideoAppCtrlReLaunching(pAppData);
 911 }
 912
 913 static void MpVideoAppCtrlPlayNextMedia(VideoAppData *pAppData)
 914 {
 915         if (!pAppData) {
 916                 VideoLogInfo("No exist appdata.");
 917                 return;
 918         }
 919
 920         VideoLogInfo("");
 921
 922         if (strlen(pAppData->szNextMediaUri) <= 0) {
 923                 VideoLogInfo("szNextMediaUri is NULL.");
 924                 return;
 925         }
 926
 927         VideoLogInfo("Current media uri : %s", pAppData->szMediaUri);
 928         VideoLogInfo("Next media uri : %s", pAppData->szNextMediaUri);
 929
 930         strncpy(pAppData->szMediaUri, pAppData->szNextMediaUri,
 931                 sizeof(pAppData->szMediaUri) - 1);
 932         MpVideoAppCtrlShowLayout(pAppData);
 933         if (pAppData->nCurPlayerType == MP_VIDEO_PLAYER) {
 934                 MpUtilMediaSvcGetPreNextVideoUrl(pAppData->szMediaUri,
 935                                                  pAppData->szPreMediaUri,
 936                                                  pAppData->szNextMediaUri);
 937         }
 938
 939         MpVideoAppCtrlReLaunching(pAppData);
 940 }
 941
 942 static void MpVideoAppCtrlGetBufferingPosition(VideoAppData *pAppData)
 943 {
 944         if (!pAppData) {
 945                 VideoLogInfo("No exist appdata.");
 946                 return;
 947         }
 948
 949         if (pAppData == NULL) {
 950                 VideoLogInfo("ERR");
 951                 return;
 952         }
 953
 954         if (pAppData->nCurPlayerType == MP_VIDEO_PLAYER) {
 955                 VideoLogInfo("Skip Normal Play mode");
 956                 return;
 957         }
 958         if(MpUtilCheckRTSPType(pAppData->szMediaUri)) {
 959                 return;
 960         }
 961         pAppData->nBufferingPosition = MpVideoCtrlMgrGetBufferingPosition();
 962 }
 963
 964
 965 static void MpVideoAppCtrlStart(VideoAppData *pAppData)
 966 {
 967         if (!pAppData) {
 968                 VideoLogInfo("No exist appdata.");
 969                 return;
 970         }
 971
 972         VideoLogInfo("");
 973
 974         if (pAppData->nCurPlayerType == MP_VIDEO_PLAYER) {
 975                 char szSubtitleUri[STR_LEN_MAX] = {0};
 976
 977                 if (!MpVideoSubtitleCtrlGetSubtitleUri(szSubtitleUri)) {
 978                         memset(szSubtitleUri, 0, STR_LEN_MAX);
 979                 } else {
 980                         VideoLogInfo("szSubtitleUriPath : %s", szSubtitleUri);
 981                 }
 982
 983                 if (!MpVideoCtrlMgrMediaCreate(pAppData->szMediaUri,
 984                                           MpVideoAppCtrlPlayerMsgCallback,
 985                                           (void *)MpUtilGetMainWindowXID(),
 986                                           szSubtitleUri,
 987                                           (void *)pAppData)) {
 988                         MpUtilNotifyPopUp(pAppData,
 989                                           "It is unable to play video contents.",
 990                                           MpVideoAppCtrlExitCb);
 991                 }
 992
 993                 if (pAppData->nSetPosition > 0) {
 994                         VideoLogInfo("Start position time : %dms",
 995                                      pAppData->nSetPosition);
 996                         MpVideoAppCtrlSetPosition(pAppData);
 997                 }
 998
 999                 MpVideoCtrlMgrMediaPlay((void *)pAppData);
1000
1001         } else if (pAppData->nCurPlayerType == MP_STREAMING_PLAYER ) {
1002                 if (MpVideoStreamingCtrlInit((void *)pAppData)) {
1003                         VideoLogInfo("Connect to network.");
1004                         MpVideoAppCtrlStartStreaming((void *)pAppData);
1005                 } else {
1006                         VideoLogInfo("No connect to network.");
1007                         MpUtilNotifyPopUp(pAppData,
1008                           "It is impossible to connect to network.",
1009                           MpVideoAppCtrlExitCb);
1010                 }
1011         }
1012 }
1013
1014 static void MpVideoAppCtrlStop(VideoAppData *pAppData)
1015 {
1016         if (!pAppData) {
1017                 VideoLogInfo("No exist appdata.");
1018                 return;
1019         }
1020
1021         VideoLogInfo("");
1022
1023         pAppData->nCurPlayerState = MP_PLAYER_STATE_STOP;
1024
1025         MpVideoCtrlMgrMediaStop((void *)pAppData);
1026 }
1027
1028 static void MpVideoAppCtrlPause(VideoAppData *pAppData)
1029 {
1030         if (!pAppData) {
1031                 VideoLogInfo("No exist appdata.");
1032                 return;
1033         }
1034
1035         VideoLogInfo("");
1036
1037         if (pAppData->nCurPlayerState == MP_PLAYER_STATE_PAUSE) {
1038                 VideoLogInfo("Allready Pause video player.");
1039                 return;
1040         }
1041
1042         pAppData->nCurPlayerState = MP_PLAYER_STATE_PAUSE;
1043
1044         MpVideoCtrlMgrMediaPause(pAppData);
1045         MpVideoViewCtrlPause(pAppData);
1046         MpVideoAppCtrlShowLayout(pAppData);
1047         MpUtilLcdNormalPowerUnlockForPause();
1048 }
1049
1050 static void MpVideoAppCtrlResume(VideoAppData *pAppData)
1051 {
1052         if (!pAppData) {
1053                 VideoLogInfo("No exist appdata.");
1054                 return;
1055         }
1056
1057         VideoLogInfo("");
1058
1059         if (pAppData->nCurPlayerState == MP_PLAYER_STATE_RESUME ||
1060             pAppData->nCurPlayerState == MP_PLAYER_STATE_PLAY) {
1061                 VideoLogInfo("Allready Resume video player.");
1062                 return;
1063         }
1064
1065         pAppData->nCurPlayerState = MP_PLAYER_STATE_RESUME;
1066         MpUtilMultimediaKeyGrab();
1067
1068         MpVideoAppCtrlGetPosition(pAppData);
1069         MpVideoCtrlMgrMediaResume(pAppData);
1070         MpVideoViewCtrlResume(pAppData);
1071         MpVideoAppCtrlShowLayout(pAppData);
1072         MpUtilLcdNormalPowerLockForResume();
1073 }
1074
1075 static void MpVideoAppCtrlStopByAppPause(VideoAppData *pAppData)
1076 {
1077         if (!pAppData) {
1078                 VideoLogInfo("No exist appdata.");
1079                 return;
1080         }
1081
1082         if (!MpVideoCtrlMgrIsExistPlayerHandle()) {
1083                 VideoLogInfo("Not exist Player handle.");
1084                 return;
1085         }
1086
1087         VideoLogInfo("");
1088
1089         MpVideoAppCtrlGetPosition(pAppData);
1090         pAppData->nSetPosition = pAppData->nCurPosition;
1091         VideoLogInfo("Current position time : %d", pAppData->nSetPosition);
1092         MpVideoViewCtrlPause(pAppData);
1093         MpVideoAppCtrlStop(pAppData);
1094         MpVideoCtrlMgrMediaDestroy(pAppData);
1095         MpUtilLcdNormalPowerUnlockForPause();
1096
1097         MpUtilMultimediaKeyUngrab();
1098
1099         if (pAppData->nCurPlayerType == MP_STREAMING_PLAYER) {
1100                 MpVideoViewSetBufferingRateForStreamingView(0, (void *)pAppData);
1101         }
1102
1103 }
1104
1105 static void MpVideoAppCtrlStartByAppResume(VideoAppData *pAppData)
1106 {
1107         if (!pAppData) {
1108                 VideoLogInfo("No exist appdata.");
1109                 return;
1110         }
1111
1112         VideoLogInfo("");
1113
1114         MpVideoAppCtrlStart(pAppData);
1115         MpVideoViewCtrlResume(pAppData);
1116         MpVideoAppCtrlShowLayout(pAppData);
1117         MpUtilLcdNormalPowerLockForResume();
1118
1119         return;
1120 }
1121
1122 static void MpVideoAppCtrlFFDown(VideoAppData *pAppData)
1123 {
1124         VideoLogInfo("");
1125 }
1126
1127 static void MpVideoAppCtrlRewDown(VideoAppData *pAppData)
1128 {
1129         VideoLogInfo("");
1130 }
1131
1132 static void MpVideoAppCtrlFFUp(VideoAppData *pAppData)
1133 {
1134         VideoLogInfo("");
1135 }
1136
1137 static void MpVideoAppCtrlRewUp(VideoAppData *pAppData)
1138 {
1139         VideoLogInfo("");
1140 }
1141
1142 static void MpVideoAppCtrlSetMute(VideoAppData *pAppData)
1143 {
1144         VideoLogInfo("");
1145
1146         if (pAppData->bIsMute) {
1147                 MpVideoCtrlMgrSetMute(TRUE);
1148         } else {
1149                 MpVideoCtrlMgrSetMute(FALSE);
1150         }
1151 }
1152
1153 static void MpVideoAppCtrlSetScreenType(VideoAppData *pAppData)
1154 {
1155         VideoLogInfo("");
1156 }
1157
1158 static void MpVideoAppCtrlSetScreenSize(VideoAppData *pAppData, int nScreenSize)
1159 {
1160         if (!pAppData) {
1161                 VideoLogInfo("No exist appdata.");
1162                 return;
1163         }
1164
1165         VideoLogInfo("");
1166
1167         switch(nScreenSize)
1168         {
1169         case MP_DISPLAY_METHOD_LETTER_BOX:      VideoLogInfo("LETTER_BOX");     break;
1170         case MP_DISPLAY_METHOD_ORIGIN_SIZE:     VideoLogInfo("ORIGIN_SIZE");    break;
1171         case MP_DISPLAY_METHOD_FULL_SCREEN:     VideoLogInfo("FULL_SCREEN");    break;
1172         case MP_DISPLAY_METHOD_CROPPED_FULL:    VideoLogInfo("CROPPED_FULL");   break;
1173         case MP_DISPLAY_METHOD_CUSTOM_ROI:      VideoLogInfo("CUSTOM_ROI");     break;
1174         default:        VideoLogInfo("Nothing.");       return;
1175         }
1176
1177         MpVideoCtrlMgrSetRatioVideoScreen((void*)pAppData, nScreenSize);
1178 }
1179
1180 static void MpVideoAppCtrlGetPosition(VideoAppData *pAppData)
1181 {
1182         pAppData->nCurPosition = MpVideoCtrlMgrGetPosition();
1183 }
1184
1185 static void MpVideoAppCtrlSetPosition(VideoAppData *pAppData)
1186 {
1187         if (!pAppData) {
1188                 VideoLogInfo("No exist appdata.");
1189                 return;
1190         }
1191
1192         VideoLogInfo("");
1193
1194         MpVideoCtrlMgrSetPosition(pAppData->nSetPosition);
1195
1196         if(MpUtilCheckRTSPType(pAppData->szMediaUri)) {
1197                 VideoLogInfo("RTSP SEEK Start");
1198                 nBufferingRate = 0;
1199                 MpVideoAppCtrlBufferingCb((void *)pAppData);
1200
1201         }
1202 }
1203
1204 static void MpVideoAppCtrlHideLayout(VideoAppData *pAppData)
1205 {
1206         if (!pAppData) {
1207                 VideoLogInfo("No exist appdata.");
1208                 return;
1209         }
1210
1211         VideoLogInfo("");
1212
1213         MpVideoViewHideLayout((void *)pAppData);
1214 }
1215
1216 static void MpVideoAppCtrlShowLayout(VideoAppData *pAppData)
1217 {
1218         if (!pAppData) {
1219                 VideoLogInfo("No exist appdata.");
1220                 return;
1221         }
1222
1223         VideoLogInfo("");
1224
1225         MpVideoViewShowLayout((void *)pAppData);
1226 }
1227
1228 static void MpVideoAppCtrlGetVideoResolution(VideoAppData *pAppData)
1229 {
1230         if (!pAppData) {
1231                 VideoLogInfo("No exist appdata.");
1232                 return;
1233         }
1234
1235         VideoLogInfo("");
1236
1237         pAppData->nVideoWidthResolution =
1238             MpVideoCtrlMgrGetVideoWidthResolution();
1239         pAppData->nVideoHeightResolution =
1240             MpVideoCtrlMgrGetVideoHeightResolution();
1241 }
1242
1243 static void MpVideoAppCtrlReqDurationTime(VideoAppData *pAppData)
1244 {
1245         if (!pAppData) {
1246                 VideoLogInfo("No exist appdata.");
1247                 return;
1248         }
1249
1250         VideoLogInfo("");
1251
1252         pAppData->nDuration = MpVideoCtrlMgrGetDuration();
1253 }
1254
1255 static void MpVideoAppCtrlBeginOfStream(VideoAppData *pAppData)
1256 {
1257         if (!pAppData) {
1258                 VideoLogInfo("No exist appdata.");
1259                 return;
1260         }
1261
1262         VideoLogInfo("");
1263
1264         pAppData->nCurPlayerState = MP_PLAYER_STATE_PLAY;
1265         MpUtilMultimediaKeyGrab();
1266
1267         MpVideoAppCtrlGetVideoResolution(pAppData);
1268         pAppData->nDuration = MpVideoCtrlMgrGetDuration();
1269         MpVideoViewCtrlInitAfterBeginOfStream((void *)pAppData);
1270 }
1271
1272 static void MpVideoAppCtrlEndOfStream(VideoAppData *pAppData)
1273 {
1274         if (!pAppData) {
1275                 VideoLogInfo("No exist appdata.");
1276                 return;
1277         }
1278
1279         VideoLogInfo("");
1280
1281         if (pAppData->nLaunchingAppType == MP_LAUNCH_APP_GALLERY ) {
1282                 if (pAppData->nCurPosition >= 0 ) {
1283                         MpUtilMediaSvcSaveLastPlayedTime(pAppData->szMediaUri, 0);
1284                 } else {
1285                         VideoLogInfo("Invalid Plaing time or duration time.");
1286                 }
1287         }
1288
1289         if (strlen(pAppData->szNextMediaUri) > 0) {
1290                 MpVideoAppCtrlPlayNextMedia(pAppData);
1291         }
1292         else {
1293                 MpVideoAppCtrlExit(pAppData);
1294         }
1295 }
1296
1297 static void MpVideoAppCtrlExit(VideoAppData *pAppData)
1298 {
1299         if (!pAppData) {
1300                 VideoLogInfo("No exist appdata.");
1301                 return;
1302         }
1303
1304         VideoLogInfo("");
1305         if(pEcorePipeHandleForErrorMsg) {
1306                 ecore_pipe_del(pEcorePipeHandleForErrorMsg);
1307                 pEcorePipeHandleForErrorMsg = NULL;
1308         }
1309
1310         if(pEcorePipeHandleBOF) {
1311                 ecore_pipe_del(pEcorePipeHandleBOF);
1312                 pEcorePipeHandleBOF = NULL;
1313         }
1314         if (pEcorePipeHandleEOF) {
1315                 ecore_pipe_del(pEcorePipeHandleEOF);
1316                 pEcorePipeHandleEOF = NULL;
1317         }
1318
1319         if (pEcorePipeHandleForBuffering) {
1320                 ecore_pipe_del(pEcorePipeHandleForBuffering);
1321                 pEcorePipeHandleForBuffering = NULL;
1322         }
1323
1324         if (pEcorePipeHandleForBluetooth) {
1325                 ecore_pipe_del(pEcorePipeHandleForBluetooth);
1326                 pEcorePipeHandleForBluetooth = NULL;
1327         }
1328
1329         if (pEcorePipeHandleForSubTitle) {
1330                 ecore_pipe_del(pEcorePipeHandleForSubTitle);
1331                 pEcorePipeHandleForSubTitle = NULL;
1332         }
1333         if (pEcorePipeHandleForResumed) {
1334                 ecore_pipe_del(pEcorePipeHandleForResumed);
1335                 pEcorePipeHandleForResumed = NULL;
1336         }
1337         if (pEcorePipeHandleForInterruped) {
1338                 ecore_pipe_del(pEcorePipeHandleForInterruped);
1339                 pEcorePipeHandleForInterruped = NULL;
1340         }
1341
1342         MpVideoAppCtrlStop(pAppData);
1343         MpVideoCtrlMgrMediaDestroy(pAppData);
1344
1345         MpUtilDeletePopupHandle();
1346
1347         MpVideoViewCtrlDestroy((void *)pAppData);
1348
1349         if (pAppData->nCurPlayerType == MP_STREAMING_PLAYER) {
1350                 MpVideoStreamingCtrlDestroy((void *)pAppData);
1351         }
1352
1353         elm_win_indicator_mode_set(pAppData->pMainWindow, ELM_WIN_INDICATOR_SHOW);
1354
1355         elm_exit();
1356 }
1357
1358 static void MpVideoAppCtrlStartStreaming(VideoAppData *pAppData)
1359 {
1360         if (!pAppData) {
1361                 VideoLogInfo("No exist appdata.");
1362                 return;
1363         }
1364
1365         VideoLogInfo("");
1366
1367         MpVideoCtrlMgrMediaCreate(pAppData->szMediaUri,
1368                                   MpVideoAppCtrlPlayerMsgCallback,
1369                                   (void *)MpUtilGetMainWindowXID(),
1370                                   NULL,
1371                                   (void *)pAppData);
1372
1373         MpVideoCtrlMgrMediaPlay((void *)pAppData);
1374
1375         if (pAppData->nSetPosition > 0) {
1376                 VideoLogInfo("Start position time : %dms",
1377                              pAppData->nSetPosition);
1378                 MpVideoAppCtrlSetPosition(pAppData);
1379         }
1380 }
1381
1382
1383 static void MpVideoAppCtrlReLaunching(VideoAppData *pAppData)
1384 {
1385         if (!pAppData) {
1386                 VideoLogInfo("No exist appdata.");
1387                 return;
1388         }
1389
1390         VideoLogInfo("");
1391
1392         MpVideoAppCtrlStop(pAppData);
1393         MpVideoCtrlMgrMediaDestroy(pAppData);
1394
1395         pAppData->nSetPosition = 0;
1396
1397         if (pAppData->nCurPlayerType == MP_VIDEO_PLAYER) {
1398                 memset(pAppData->szVideoTitle, 0, STR_LEN_MAX);
1399                 MpUtilGetTitleFromFilepath(pAppData->szMediaUri, pAppData->szVideoTitle);
1400                 MpVideoSubtitleCtrlInit(pAppData);
1401         }
1402
1403         MpVideoViewCtrlChangeTitle(pAppData);
1404
1405         if (pAppData->nCurPlayerType == MP_VIDEO_PLAYER) {
1406                 MpVideoAppCtrlStart(pAppData);
1407         } else if (pAppData->nCurPlayerType == MP_STREAMING_PLAYER) {
1408                 MpVideoAppCtrlStartStreaming(pAppData);
1409         }
1410
1411         MpVideoAppCtrlSetMute(pAppData);
1412 }
1413
1414 static void MpVideoAppCtrlPipeInit(VideoAppData *pAppData)
1415 {
1416         if (!pAppData) {
1417                 VideoLogInfo("No exist appdata.");
1418                 return;
1419         }
1420
1421         VideoLogInfo("");
1422         if(pEcorePipeHandleForErrorMsg) {
1423                 ecore_pipe_del(pEcorePipeHandleForErrorMsg);
1424                 pEcorePipeHandleForErrorMsg = NULL;
1425         }
1426         pEcorePipeHandleForErrorMsg = ecore_pipe_add(
1427                 (Ecore_Pipe_Cb)MpVideoAppCtrlMmfErrormsgCb,
1428                 (void *)pAppData);
1429
1430         if(pEcorePipeHandleBOF) {
1431                 ecore_pipe_del(pEcorePipeHandleBOF);
1432                 pEcorePipeHandleBOF = NULL;
1433         }
1434         pEcorePipeHandleBOF = ecore_pipe_add(
1435                 (Ecore_Pipe_Cb)MpVideoAppCtrlBeginOfPlayCb,
1436                 (void *)pAppData);
1437
1438         if(pEcorePipeHandleEOF) {
1439                 ecore_pipe_del(pEcorePipeHandleEOF);
1440                 pEcorePipeHandleEOF = NULL;
1441         }
1442         pEcorePipeHandleEOF = ecore_pipe_add(
1443                 (Ecore_Pipe_Cb)MpVideoAppCtrlEndOfPlayCb,
1444                 (void *)pAppData);
1445
1446         if (pEcorePipeHandleForBuffering) {
1447                 ecore_pipe_del(pEcorePipeHandleForBuffering);
1448                 pEcorePipeHandleForBuffering = NULL;
1449         }
1450         pEcorePipeHandleForBuffering = ecore_pipe_add(
1451                 (Ecore_Pipe_Cb)MpVideoAppCtrlBufferingCb,
1452                 (void *)pAppData);
1453
1454         if (pEcorePipeHandleForBluetooth) {
1455                 ecore_pipe_del(pEcorePipeHandleForBluetooth);
1456                 pEcorePipeHandleForBluetooth = NULL;
1457         }
1458         pEcorePipeHandleForBluetooth = ecore_pipe_add(
1459                 (Ecore_Pipe_Cb)MpVideoAppCtrlBluetoothCb,
1460                 (void *)pAppData);
1461
1462         if (pEcorePipeHandleForSubTitle) {
1463                 ecore_pipe_del(pEcorePipeHandleForSubTitle);
1464                 pEcorePipeHandleForSubTitle = NULL;
1465         }
1466         pEcorePipeHandleForSubTitle = ecore_pipe_add(
1467                 (Ecore_Pipe_Cb)MpVideoAppCtrlUpdateSubtitleCb,
1468                 (void *)pAppData);
1469
1470         if (pEcorePipeHandleForResumed) {
1471                 ecore_pipe_del(pEcorePipeHandleForResumed);
1472                 pEcorePipeHandleForResumed = NULL;
1473         }
1474         pEcorePipeHandleForResumed = ecore_pipe_add(
1475                 (Ecore_Pipe_Cb)MpVideoAppCtrlResumeByRewCb,
1476                 (void *)pAppData);
1477
1478         if (pEcorePipeHandleForInterruped) {
1479                 ecore_pipe_del(pEcorePipeHandleForInterruped);
1480                 pEcorePipeHandleForInterruped = NULL;
1481         }
1482         pEcorePipeHandleForInterruped = ecore_pipe_add(
1483                 (Ecore_Pipe_Cb)MpVideoAppCtrlPauseByInterrupteCb,
1484                 (void *)pAppData);
1485
1486 }
1487
1488
1489
1490 /*
1491  * External function
1492  */
1493 bool MpVideoAppCtrlInit(VideoAppData *pAppData)
1494 {
1495         if (!pAppData) {
1496                 VideoLogInfo("No exist appdata.");
1497                 return FALSE;
1498         }
1499
1500         VideoLogInfo("");
1501
1502         MpVideoAppCtrlFuncInit(pAppData);
1503         MpVideoSubtitleCtrlInit(pAppData);
1504         MpVideoViewCtrlInit(pAppData);
1505
1506         if (!MpUtilCheckCallStatus()) {
1507                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_BODY_UNABLE_TO_PLAY_VIDEO_DURING_CALL), MpVideoAppCtrlExitCb);
1508                 return FALSE;
1509         }
1510
1511         if (!MpUtilCheckBatteryStatus()) {
1512                 MpUtilNotifyPopUp(pAppData, dgettext("sys_string", MP_COM_BODY_LOW_BATTERY), MpVideoAppCtrlExitCb);
1513                 return FALSE;
1514         }
1515
1516         if (pAppData->nCurPlayerType == MP_VIDEO_PLAYER) {
1517                 if (!MpUtilCheckLocalFileExist(pAppData->szMediaUri)) {
1518                         MpUtilNotifyPopUp(pAppData, "File not Exist", MpVideoAppCtrlExitCb);
1519                         return FALSE;
1520                 }
1521
1522                 memset(pAppData->szVideoTitle, 0, STR_LEN_MAX);
1523                 MpUtilGetTitleFromFilepath(pAppData->szMediaUri, pAppData->szVideoTitle);
1524                 MpVideoViewCtrlChangeTitle(pAppData);
1525         }
1526
1527         MpVideoAppCtrlPipeInit(pAppData);
1528
1529         MpVideoAppCtrlStart(pAppData);
1530
1531         return TRUE;
1532 }
1533
1534 bool MpVideoAppCtrlResetForRelaunching(VideoAppData *pAppData)
1535 {
1536         if (!pAppData) {
1537                 VideoLogInfo("No exist appdata.");
1538                 return FALSE;
1539         }
1540
1541         VideoLogInfo("");
1542
1543         MpVideoAppCtrlStop(pAppData);
1544         MpVideoCtrlMgrMediaDestroy(pAppData);
1545         MpUtilDeletePopupHandle();
1546         MpVideoViewCtrlDestroy((void *)pAppData);
1547         MpUtilMediaSvcDestoryVideoList();
1548         MpUtilMediaSvcFinishSession();
1549         MpUtilMediaSvcMtagIterateDestroyTagList();
1550         MpUtilMMCstatusNotiIgnore();
1551         MpUtilBatteryStatusNotiIgnore();
1552         MpVideoSubtitleCtrlDestroy();
1553
1554         nBufferingRate = 0;
1555         nErrorCode = 0;
1556
1557         pAppData->bIsMute = FALSE;
1558         pAppData->nDuration = 0;
1559         pAppData->nSetPosition = 0;
1560         pAppData->nCurPosition = 0;
1561         pAppData->nSubtitleDuration = 0;
1562         pAppData->nBufferingPosition = 0;
1563         pAppData->nVideoWidthResolution = 0;
1564         pAppData->nVideoHeightResolution = 0;
1565
1566         memset(pAppData->szSubtitle, 0, sizeof(char) * STR_LEN_MAX);
1567         memset(pAppData->szVideoTitle, 0, sizeof(char) * STR_LEN_MAX);
1568         memset(pAppData->szMediaUri, 0, sizeof(char) * STR_LEN_MAX);
1569         memset(pAppData->szPreMediaUri, 0, sizeof(char) * STR_LEN_MAX);
1570         memset(pAppData->szNextMediaUri, 0, sizeof(char) * STR_LEN_MAX);
1571         memset(pAppData->szTagNameForVideoList, 0, sizeof(char) * STR_LEN_MAX);
1572
1573         pAppData->nPrePlayerState = MP_PLAYER_STATE_CLEAR;
1574         pAppData->nCurPlayerState = MP_PLAYER_STATE_CLEAR;
1575         pAppData->nLaunchingAppType = MP_LAUNCH_APP_DEFAULT;
1576         pAppData->nVideoSortType = MP_MEDIA_SORT_BY_NONE;
1577         pAppData->nVideoListType = MP_VIDEO_LIST_TYPE_FOLDER;
1578         pAppData->nCurPlayerType = MP_STREAMING_PLAYER;
1579
1580         memset(pAppData->szProxyAddress, 0, sizeof(char) * STR_LEN_MAX);
1581         memset(pAppData->szUserAgent, 0, sizeof(char) * STR_LEN_MAX);
1582         memset(pAppData->szCookie, 0, sizeof(char) * STR_LEN_MAX);
1583
1584         MpUtilResetForRelaunching();
1585
1586         return TRUE;
1587 }
1588
1589 bool MpVideoAppCtrlIsTopView(void* pUserData)
1590 {
1591         if (!pUserData) {
1592                 VideoLogInfo("No exist pUserData.");
1593                 return FALSE;
1594         }
1595
1596         VideoLogInfo("");
1597
1598         return MpVideoViewCtrlIsTopView(pUserData);
1599 }
1600
1601 bool MpVideoAppCtrlIsExistPlayerHandle(void)
1602 {
1603         VideoLogInfo("");
1604
1605         return MpVideoCtrlMgrIsExistPlayerHandle();
1606 }