src/mp-video-progressbar.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 "mp-util.h"
  19 #include "mp-video-log.h"
  20 #include "video-player.h"
  21 #include "mp-video-value-define.h"
  22 #include "mp-video-service-ctrl.h"
  23 #include "mp-video-progressbar.h"
  24
  25 #define PROGRESS_BAR_START_TERM                 130
  26 #define PROGRESS_BAR_WIDTH_TERM                 200
  27
  28 #define PROGRESS_ADJUSTMENT_TIME_INTERVAL       2.0
  29 #define PROGRESS_ADJUSTMENT_RUN_INTERVAL        0.3
  30
  31 #define PROGRESS_ADJUSTMENT_MOVE_LIMIT          20
  32 #define PROGRESS_ADJUSTMENT_MODE_LIMIT          20
  33
  34
  35 static Evas_Object *pProgressbarEdj = NULL;
  36 static Ecore_Timer *pProgressbarTimer = NULL;
  37
  38 static Ecore_Timer *pProgressAdjustCheckTimer = NULL;
  39 static Ecore_Timer *pProgressAdjustRunTimer = NULL;
  40
  41 static bool bIsEventSkip = FALSE;
  42 static bool bIsDrag = FALSE;
  43 static int nDragPosition = 0;
  44
  45 static bool bIsAdjustmentMode = FALSE;
  46 static int nDownPosX = 0;
  47 static int nOldPosX = 0;
  48 static bool bPrevAdjustment = FALSE;
  49
  50
  51 static void MpVideoProgressbarSetAdjustmentMode(bool bShow)
  52 {
  53         VideoLogInfo("");
  54
  55         if(bShow) {
  56                 edje_object_signal_emit(pProgressbarEdj, SIGNAL_PROGRESS_ADJUSTMENT_SHOW, "*");
  57         }
  58         else {
  59                 edje_object_signal_emit(pProgressbarEdj, SIGNAL_PROGRESS_ADJUSTMENT_HIDE, "*");
  60         }
  61 }
  62
  63
  64 static void MpVideoProgressbarSetPointerVisible(bool bVisible)
  65 {
  66         VideoLogInfo("");
  67
  68         if(bVisible) {
  69                 edje_object_signal_emit(pProgressbarEdj, SIGNAL_PROGRESS_POINTER_SHOW, "*");
  70         }
  71         else {
  72                 edje_object_signal_emit(pProgressbarEdj, SIGNAL_PROGRESS_POINTER_HIDE, "*");
  73         }
  74 }
  75
  76 /*
  77  * Internal function
  78  */
  79 static Eina_Bool MpVideoProgressbarUpdateValue(void *pUserData)
  80 {
  81         //VideoLogInfo("");
  82
  83         if (!pUserData) {
  84                 VideoLogInfo("[ERR] No exist userdata.");
  85                 return EINA_TRUE;
  86         }
  87
  88         VideoAppData *pAppData = (VideoAppData *)pUserData;
  89
  90         double nPlayedRatio = 0.0;
  91         char szPlayingTime[PLAY_TIME_LENGTH] = { 0, };
  92
  93         nPlayedRatio = ((double)nDragPosition / (double)pAppData->nDuration);
  94
  95         snprintf(szPlayingTime, PLAY_TIME_LENGTH, "%" PLAY_TIME_FORMAT,
  96                  PLAY_TIME_ARGS(nDragPosition / 1000));
  97
  98         edje_object_part_drag_value_set(pProgressbarEdj, "progress.playing",
  99                                         nPlayedRatio, 0.0);
 100
 101         edje_object_part_text_set(pProgressbarEdj, "progress.txt.played",
 102                                   szPlayingTime);
 103
 104         if(bIsAdjustmentMode) {
 105                 edje_object_part_text_set(pProgressbarEdj, "progress.adjustment.txt",
 106                                   szPlayingTime);
 107         }
 108
 109         return EINA_TRUE;
 110 }
 111
 112 static void MpVideoProgressbarUpdateBufferingValue(void *pUserData)
 113 {
 114         //VideoLogInfo("");
 115
 116         if (!pUserData) {
 117                 VideoLogInfo("[ERR] No exist userdata.");
 118                 return;
 119         }
 120
 121         VideoAppData *pAppData = (VideoAppData *)pUserData;
 122
 123         double buffering_ratio = 0.0;
 124         pAppData->
 125             VideoAppCtrlCallbackFunc.VideoAppCtrlGetBufferingPosition(pAppData);
 126
 127         buffering_ratio = ((double)pAppData->nBufferingPosition / (double)100);
 128
 129         //VideoLogInfo("%d:%lf", pAppData->nBufferingPosition, buffering_ratio);
 130
 131         edje_object_part_drag_value_set(pProgressbarEdj, "progress.buffering",
 132                                         buffering_ratio, 0.0);
 133 }
 134
 135 /*
 136  * Callback function.
 137  */
 138 static Eina_Bool MpVideoProgressbarTimerCb(void *pUserData)
 139 {
 140         /* VideoLogInfo(""); */
 141
 142         if (!pUserData) {
 143                 VideoLogInfo("[ERR] No exist userdata.");
 144                 return EINA_TRUE;
 145         }
 146
 147         VideoAppData *pAppData = (VideoAppData *)pUserData;
 148
 149         if (pAppData->nDuration < 1) {
 150                 VideoLogInfo("Try to update duration time.");
 151                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlReqDurationTime(pAppData);
 152                 return EINA_TRUE;
 153         }
 154
 155         if (bIsEventSkip || bIsDrag)
 156                 return EINA_TRUE;
 157
 158         double nPlayedRatio = 0.0;
 159         char szPlayingTime[PLAY_TIME_LENGTH] = { 0, };
 160
 161         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlGetPosition(pAppData);
 162
 163         nPlayedRatio = ((double)pAppData->nCurPosition / (double)pAppData->nDuration);
 164         snprintf(szPlayingTime, PLAY_TIME_LENGTH, "%" PLAY_TIME_FORMAT, PLAY_TIME_ARGS(pAppData->nCurPosition / 1000));
 165
 166         edje_object_part_drag_value_set(pProgressbarEdj, "progress.playing", nPlayedRatio, 0.0);
 167         edje_object_part_text_set(pProgressbarEdj, "progress.txt.played", szPlayingTime);
 168
 169         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerTypeWithoutLog();
 170         if(nTmpPlayerType == MP_STREAMING_PLAYER)
 171         {
 172                 MpVideoProgressbarUpdateBufferingValue(pUserData);
 173         }
 174
 175         return EINA_TRUE;
 176 }
 177
 178 static Eina_Bool MpVideoProgressbarAdjustmentTimerCb(void *pUserData)
 179 {
 180         VideoLogInfo("");
 181
 182         if (!pUserData) {
 183                 VideoLogError("[ERR] No exist userdata.");
 184                 return EINA_FALSE;
 185         }
 186         VideoAppData *pAppData = (VideoAppData *)pUserData;
 187
 188         bIsAdjustmentMode = TRUE;
 189
 190         VideoLogInfo("%d, %d",pAppData->nCurPosition , nDragPosition);
 191
 192         pAppData->nSetPosition = nDragPosition;
 193         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetPosition(pAppData);
 194
 195         MpVideoProgressbarSetAdjustmentMode(bIsAdjustmentMode);
 196         MpVideoProgressbarUpdateValue(pUserData);
 197         return EINA_FALSE;
 198 }
 199
 200 static Eina_Bool MpVideoProgressbarAdjustmentRunTimerCb(void *pUserData)
 201 {
 202 //      VideoLogInfo("");
 203
 204         if (!pUserData) {
 205                 VideoLogInfo("[ERR] No exist userdata.");
 206                 return EINA_TRUE;
 207         }
 208
 209         VideoAppData *pAppData = (VideoAppData *)pUserData;
 210
 211
 212         if(bPrevAdjustment) {
 213                 pAppData->nSetPosition = nDragPosition - 1000;
 214         }
 215         else {
 216                 pAppData->nSetPosition = nDragPosition + 1000;
 217         }
 218
 219         if (pAppData->nSetPosition < 0) {
 220                 pAppData->nSetPosition = 0;
 221         }
 222
 223         if (pAppData->nSetPosition > pAppData->nDuration) {
 224                 pAppData->nSetPosition = pAppData->nDuration;
 225         }
 226
 227         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetPosition(pAppData);
 228
 229         nDragPosition = pAppData->nSetPosition;
 230
 231         MpVideoProgressbarUpdateValue((void *)pAppData);
 232
 233
 234
 235         return EINA_TRUE;
 236 }
 237
 238
 239
 240 static void MpVideoProgressbarDownCb(void *pUserData, Evas * e,
 241                                      Evas_Object *obj, void *event_info)
 242 {
 243         VideoLogInfo("");
 244
 245         if (!pUserData) {
 246                 VideoLogInfo("[ERR]");
 247                 return;
 248         }
 249
 250         if (!event_info) {
 251                 VideoLogInfo("[ERR]");
 252                 return;
 253         }
 254
 255         if (bIsEventSkip)
 256                 return;
 257
 258         MpVideoProgressbarDeleteTimer();
 259         MpVideoProgressbarSetPointerVisible(TRUE);
 260
 261         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerTypeWithoutLog();
 262         if(nTmpPlayerType != MP_STREAMING_PLAYER)
 263         {
 264                 if(pProgressAdjustCheckTimer) {
 265                         ecore_timer_del(pProgressAdjustCheckTimer);
 266                         pProgressAdjustCheckTimer = NULL;
 267                 }
 268
 269                 if(pProgressAdjustRunTimer) {
 270                         ecore_timer_del(pProgressAdjustRunTimer);
 271                         pProgressAdjustRunTimer = NULL;
 272                 }
 273
 274                 pProgressAdjustCheckTimer = ecore_timer_add(PROGRESS_ADJUSTMENT_TIME_INTERVAL,
 275                                         MpVideoProgressbarAdjustmentTimerCb, (void *)pUserData);
 276
 277         }
 278         bIsDrag = TRUE;
 279
 280         VideoAppData *pAppData = (VideoAppData *)pUserData;
 281         Evas_Event_Mouse_Up *ev = event_info;
 282         Evas_Object *progressbar = obj;
 283         int w = 0, current = 0;
 284         double ratio = 0.0;
 285
 286         int term = 0;
 287         int w_term = 0;
 288         int width = 0;
 289         int height = 0;
 290
 291         ecore_x_window_size_get(ecore_x_window_root_first_get(),&width, &height);
 292         term = PROGRESS_BAR_START_TERM * width/DEFAULT_SCALE_WIDTH;
 293         w_term = PROGRESS_BAR_WIDTH_TERM * width/DEFAULT_SCALE_WIDTH;
 294         evas_object_geometry_get(progressbar, NULL, NULL, &w, NULL);
 295         nDownPosX = ev->canvas.x;
 296         nOldPosX = ev->canvas.x;;
 297         current = ev->canvas.x - term;
 298         w = w - w_term;
 299         if (current < 0)
 300                 current = 0;
 301         else if (current > w)
 302                 current = w;
 303
 304         ratio = (double)current / w;
 305
 306         nDragPosition = ratio * pAppData->nDuration;
 307         pAppData->nSetPosition = nDragPosition;
 308
 309         if(nTmpPlayerType != MP_STREAMING_PLAYER)
 310         {
 311                 if (pAppData->nCurPlayerState == MP_PLAYER_STATE_PLAY ||
 312                     pAppData->nCurPlayerState == MP_PLAYER_STATE_RESUME) {
 313                         //pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPause(pAppData);
 314                         pAppData->nPrePlayerState = MP_PLAYER_STATE_RESUME;
 315                         pAppData->nSeekPlayerState = MP_PLAYER_STATE_PAUSE;
 316                 }
 317                 pAppData->bSeekComplete = FALSE;
 318                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetPosition(pAppData);
 319         }
 320         else {
 321                 if (pAppData->nCurPlayerState == MP_PLAYER_STATE_PLAY ||
 322                     pAppData->nCurPlayerState == MP_PLAYER_STATE_RESUME) {
 323                         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPause(pAppData);
 324                         pAppData->nPrePlayerState = MP_PLAYER_STATE_RESUME;
 325                 }
 326         }
 327
 328         MpVideoProgressbarUpdateValue(pUserData);
 329
 330 }
 331
 332 static void MpVideoProgressbarUpCb(void *pUserData, Evas * e, Evas_Object *obj,
 333                                    void *event_info)
 334 {
 335         VideoLogInfo("");
 336
 337         if (!pUserData) {
 338                 VideoLogInfo("[ERR]");
 339                 return;
 340         }
 341
 342         if (!event_info) {
 343                 VideoLogInfo("[ERR]");
 344                 return;
 345         }
 346
 347         if (bIsEventSkip)
 348                 return;
 349
 350         bIsDrag = FALSE;
 351
 352         VideoAppData *pAppData = (VideoAppData *)pUserData;
 353         MpVideoProgressbarSetPointerVisible(FALSE);
 354
 355         if(pProgressAdjustRunTimer) {
 356                 ecore_timer_del(pProgressAdjustRunTimer);
 357                 pProgressAdjustRunTimer = NULL;
 358         }
 359
 360         if(pProgressAdjustCheckTimer) {
 361                 ecore_timer_del(pProgressAdjustCheckTimer);
 362                 pProgressAdjustCheckTimer = NULL;
 363         }
 364         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerTypeWithoutLog();
 365         if(nTmpPlayerType != MP_STREAMING_PLAYER)
 366         {
 367                 if(bIsAdjustmentMode) {
 368                         bIsAdjustmentMode = FALSE;
 369                         MpVideoProgressbarSetAdjustmentMode(bIsAdjustmentMode);
 370
 371                         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetPosition(pAppData);
 372
 373                         if (pAppData->nPrePlayerState == MP_PLAYER_STATE_PLAY ||
 374                             pAppData->nPrePlayerState == MP_PLAYER_STATE_RESUME) {
 375                                 //pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlResume(pAppData);
 376                                 pAppData->nPrePlayerState = MP_PLAYER_STATE_PAUSE;
 377                                 pAppData->nSeekPlayerState = MP_PLAYER_STATE_RESUME;
 378                         }
 379                         nOldPosX = 0;
 380                         return;
 381                 }
 382         }
 383
 384         Evas_Event_Mouse_Up *ev = event_info;
 385         Evas_Object *progressbar = obj;
 386         int w = 0, current = 0;
 387         double ratio = 0.0;
 388
 389         int term = 0;
 390         int w_term = 0;
 391         int width = 0;
 392         int height = 0;
 393
 394         ecore_x_window_size_get(ecore_x_window_root_first_get(),&width, &height);
 395         term = PROGRESS_BAR_START_TERM * width/DEFAULT_SCALE_WIDTH;
 396         w_term = PROGRESS_BAR_WIDTH_TERM * width/DEFAULT_SCALE_WIDTH;
 397
 398         evas_object_geometry_get(progressbar, NULL, NULL, &w, NULL);
 399         current = ev->canvas.x - term;
 400         w = w - w_term;
 401
 402         if (current < 0)
 403                 current = 0;
 404         else if (current > w)
 405                 current = w;
 406
 407         ratio = (double)current / w;
 408
 409         pAppData->nSetPosition = (int)pAppData->nDuration * ratio;
 410
 411         if (pAppData->nSetPosition > pAppData->nDuration)
 412                 pAppData->nSetPosition = pAppData->nDuration;
 413
 414         if (pAppData->nSetPosition < 0)
 415                 pAppData->nSetPosition = 0;
 416
 417         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlGetPosition(pAppData);
 418
 419         MpVideoProgressbarCreateTimer((void *)pAppData);
 420
 421         if(nTmpPlayerType != MP_STREAMING_PLAYER)
 422         {
 423
 424                 if (pAppData->nPrePlayerState == MP_PLAYER_STATE_PLAY ||
 425                     pAppData->nPrePlayerState == MP_PLAYER_STATE_RESUME) {
 426                         //pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlResume(pAppData);
 427                         pAppData->nPrePlayerState = MP_PLAYER_STATE_PAUSE;
 428                         pAppData->nSeekPlayerState = MP_PLAYER_STATE_RESUME;
 429                 }
 430
 431                 if(!pAppData->bSeekComplete)
 432                 {
 433                         pAppData->nSeekPosition = pAppData->nSetPosition;
 434                         if((pAppData->nCurPosition < pAppData->nSeekPosition + 5000) &&
 435                                 (pAppData->nCurPosition > pAppData->nSeekPosition - 5000))
 436                         {
 437                                 VideoLogError("Skip for same position");
 438                                 pAppData->nSeekPosition = 0;
 439                         }
 440                 }
 441                 else
 442                 {
 443                         if((pAppData->nCurPosition < pAppData->nSetPosition + 5000) &&
 444                                 (pAppData->nCurPosition > pAppData->nSetPosition - 5000))
 445                         {
 446                                 VideoLogError("Skip for same position");
 447                 }
 448                 else
 449                 {
 450                         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetPosition(pAppData);
 451                 }
 452                 }
 453         }
 454         else
 455         {
 456                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetPosition(pAppData);
 457                 MpVideoProgressbarCreateTimer((void *)pAppData);
 458
 459                 if (pAppData->nPrePlayerState == MP_PLAYER_STATE_PLAY ||
 460                     pAppData->nPrePlayerState == MP_PLAYER_STATE_RESUME) {
 461                         pAppData->nSeekPlayerState = MP_PLAYER_STATE_RESUME;
 462                         pAppData->nPrePlayerState = MP_PLAYER_STATE_PAUSE;
 463                 }
 464
 465         }
 466 }
 467 static void MpVideoProgressbarMoveCb(void *pUserData, Evas * e,
 468                                      Evas_Object *obj, void *event_info)
 469 {
 470 //      VideoLogInfo("");
 471
 472         if (!pUserData) {
 473                 VideoLogInfo("[ERR]");
 474                 return;
 475         }
 476
 477         if (!event_info) {
 478                 VideoLogInfo("[ERR]");
 479                 return;
 480         }
 481
 482         if (bIsEventSkip || bIsDrag == FALSE)
 483                 return;
 484
 485         VideoAppData *pAppData = (VideoAppData *)pUserData;
 486         Evas_Event_Mouse_Up *ev = event_info;
 487         Evas_Object *progressbar = obj;
 488         int w = 0, current = 0;
 489         double ratio = 0.0;
 490
 491         int term = 0;
 492         int w_term = 0;
 493         int width = 0;
 494         int height = 0;
 495
 496         ecore_x_window_size_get(ecore_x_window_root_first_get(),&width, &height);
 497         term = PROGRESS_BAR_START_TERM * width/DEFAULT_SCALE_WIDTH;
 498         w_term = PROGRESS_BAR_WIDTH_TERM * width/DEFAULT_SCALE_WIDTH;
 499
 500         evas_object_geometry_get(progressbar, NULL, NULL, &w, NULL);
 501         if(bIsAdjustmentMode) {
 502                 if((nOldPosX + PROGRESS_ADJUSTMENT_MODE_LIMIT) < ev->canvas.x) {
 503                         if(bPrevAdjustment == TRUE) {
 504                                 if(pProgressAdjustRunTimer) {
 505                                         ecore_timer_del(pProgressAdjustRunTimer);
 506                                         pProgressAdjustRunTimer = NULL;
 507                                 }
 508                         }
 509                         bPrevAdjustment = FALSE;
 510                         nOldPosX = ev->canvas.x;
 511                 }
 512                 else if((nOldPosX - PROGRESS_ADJUSTMENT_MODE_LIMIT) > ev->canvas.x) {
 513                         if(bPrevAdjustment == FALSE) {
 514                                 if(pProgressAdjustRunTimer) {
 515                                         ecore_timer_del(pProgressAdjustRunTimer);
 516                                         pProgressAdjustRunTimer = NULL;
 517                                 }
 518                         }
 519                         bPrevAdjustment = TRUE;
 520                         nOldPosX = ev->canvas.x;
 521                 }
 522
 523                 if(pProgressAdjustRunTimer == NULL) {
 524                         pProgressAdjustRunTimer = ecore_timer_add(PROGRESS_ADJUSTMENT_RUN_INTERVAL,
 525                                                         MpVideoProgressbarAdjustmentRunTimerCb, (void *)pAppData);
 526
 527                 }
 528
 529         }
 530         else {
 531                 if(((nDownPosX + PROGRESS_ADJUSTMENT_MOVE_LIMIT) < ev->canvas.x ) ||
 532                         ((nDownPosX - PROGRESS_ADJUSTMENT_MOVE_LIMIT) > ev->canvas.x)) {
 533                         VideoLogInfo("Adjustment Off");
 534
 535                         if(pProgressAdjustCheckTimer) {
 536                                 ecore_timer_del(pProgressAdjustCheckTimer);
 537                                 pProgressAdjustCheckTimer = NULL;
 538                         }
 539
 540                         if(pProgressAdjustRunTimer) {
 541                                 ecore_timer_del(pProgressAdjustRunTimer);
 542                                 pProgressAdjustRunTimer = NULL;
 543                         }
 544                 }
 545                 current = ev->canvas.x - term;
 546                 w = w - w_term;
 547
 548                 if (current < 0)
 549                         current = 0;
 550                 else if (current > w)
 551                         current = w;
 552
 553                 ratio = (double)current / w;
 554                 nDragPosition = ratio * pAppData->nDuration;
 555                 pAppData->nSetPosition = nDragPosition;
 556                 int nTmpPlayerType = MpVideoServiceCtrlGetPlayerTypeWithoutLog();
 557                 if(nTmpPlayerType != MP_STREAMING_PLAYER)
 558                 {
 559                         if(pAppData->bSeekComplete) {
 560                                 pAppData->bSeekComplete = FALSE;
 561                                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetPosition(pAppData);
 562                         }
 563                 }
 564                 MpVideoProgressbarUpdateValue(pUserData);
 565         }
 566 }
 567
 568 /*
 569  * External function
 570  */
 571 void MpVideoProgressbarSetSkipEvent(bool bSkip)
 572 {
 573 //      VideoLogInfo("");
 574
 575         bIsEventSkip = bSkip;
 576 }
 577
 578 void *MpVideoProgressbarGetEdjHandle(void)
 579 {
 580         VideoLogInfo("");
 581
 582         if (pProgressbarEdj) {
 583                 return (void *)pProgressbarEdj;
 584         } else {
 585                 VideoLogInfo("Progressbar edj handle is null.");
 586                 return NULL;
 587         }
 588 }
 589
 590 void *MpVideoProgressbarInit(void *pUserData)
 591 {
 592         VideoLogInfo("");
 593
 594         if (!pUserData) {
 595                 VideoLogInfo("[ERR]");
 596                 return NULL;
 597         }
 598
 599         VideoAppData *pAppData = (VideoAppData *)pUserData;
 600
 601         Evas *pMainWindowEvas = evas_object_evas_get(pAppData->pMainWindow);
 602
 603         pProgressbarEdj = (Evas_Object *)MpUtilLoadEdjFile(pMainWindowEvas,
 604                                                            VIDEO_PLAYER_PROGRESS_EDJ,
 605                                                            PROGRESS_EDJ_GROUP);
 606
 607         evas_object_event_callback_add(pProgressbarEdj,
 608                                        EVAS_CALLBACK_MOUSE_DOWN,
 609                                        MpVideoProgressbarDownCb, pAppData);
 610
 611         evas_object_event_callback_add(pProgressbarEdj,
 612                                        EVAS_CALLBACK_MOUSE_UP,
 613                                        MpVideoProgressbarUpCb, pAppData);
 614
 615         evas_object_event_callback_add(pProgressbarEdj,
 616                                        EVAS_CALLBACK_MOUSE_MOVE,
 617                                        MpVideoProgressbarMoveCb, pAppData);
 618
 619         MpVideoProgressbarUpdateDurationTime("--:--:--");
 620
 621         return (void *)pProgressbarEdj;
 622 }
 623
 624 void MpVideoProgressbarDestroy(void)
 625 {
 626         VideoLogInfo("");
 627
 628         if (pProgressbarEdj) {
 629                 evas_object_del(pProgressbarEdj);
 630                 pProgressbarEdj = NULL;
 631         }
 632
 633         if (pProgressbarTimer) {
 634                 ecore_timer_del(pProgressbarTimer);
 635                 pProgressbarTimer = NULL;
 636         }
 637
 638         if(pProgressAdjustCheckTimer) {
 639                 ecore_timer_del(pProgressAdjustCheckTimer);
 640                 pProgressAdjustCheckTimer = NULL;
 641         }
 642
 643         if(pProgressAdjustRunTimer) {
 644                 ecore_timer_del(pProgressAdjustRunTimer);
 645                 pProgressAdjustRunTimer = NULL;
 646         }
 647
 648         bIsEventSkip = FALSE;
 649         nDragPosition = 0;
 650 }
 651
 652 void MpVideoProgressbarCreateTimer(void *pUserData)
 653 {
 654         VideoLogInfo("");
 655
 656         if (!pUserData) {
 657                 VideoLogInfo("[ERR]");
 658                 return;
 659         }
 660
 661         VideoAppData *pAppData = (VideoAppData *)pUserData;
 662
 663         if (pProgressbarTimer) {
 664                 ecore_timer_del(pProgressbarTimer);
 665                 pProgressbarTimer = NULL;
 666         }
 667
 668         if (bIsEventSkip)
 669                 return;
 670
 671         double nPlayedRatio = 0.0;
 672         char szPlayingTime[PLAY_TIME_LENGTH] = { 0, };
 673
 674         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlGetPosition(pAppData);
 675
 676         nPlayedRatio = ((double)pAppData->nCurPosition / (double)pAppData->nDuration);
 677         snprintf(szPlayingTime, PLAY_TIME_LENGTH, "%" PLAY_TIME_FORMAT, PLAY_TIME_ARGS(pAppData->nCurPosition / 1000));
 678
 679         edje_object_part_drag_value_set(pProgressbarEdj, "progress.playing", nPlayedRatio, 0.0);
 680         edje_object_part_text_set(pProgressbarEdj, "progress.txt.played", szPlayingTime);
 681
 682         pProgressbarTimer = ecore_timer_add(0.3, MpVideoProgressbarTimerCb, (void *)pAppData);
 683 }
 684
 685 void MpVideoProgressbarDeleteTimer(void)
 686 {
 687         VideoLogInfo("");
 688
 689         if (pProgressbarTimer) {
 690                 ecore_timer_del(pProgressbarTimer);
 691                 pProgressbarTimer = NULL;
 692         }
 693
 694         if(pProgressAdjustCheckTimer) {
 695                 ecore_timer_del(pProgressAdjustCheckTimer);
 696                 pProgressAdjustCheckTimer = NULL;
 697         }
 698
 699         if(pProgressAdjustRunTimer) {
 700                 ecore_timer_del(pProgressAdjustRunTimer);
 701                 pProgressAdjustRunTimer = NULL;
 702         }
 703 }
 704
 705 void MpVideoProgressbarUpdateDurationTime(char *szDurationTime)
 706 {
 707         VideoLogInfo("");
 708
 709         if (!szDurationTime) {
 710                 VideoLogInfo("Fail to ser duration time");
 711                 return;
 712         }
 713
 714         edje_object_part_text_set(pProgressbarEdj, "progress.txt.total",
 715                                   szDurationTime);
 716 }
 717
 718 void MpVideoProgressbarBeginOfStream(void *pUserData)
 719 {
 720         VideoLogInfo("");
 721
 722         if (!pUserData) {
 723                 VideoLogInfo("[ERR]");
 724                 return;
 725         }
 726
 727         VideoAppData *pAppData = (VideoAppData *)pUserData;
 728
 729         MpVideoProgressbarDeleteTimer();
 730
 731         pAppData->nCurPosition = 0;
 732         edje_object_part_drag_value_set(pProgressbarEdj, "progress.playing", 0.0, 0.0);
 733         edje_object_part_text_set(pProgressbarEdj, "progress.txt.played", "00:00:00");
 734
 735         MpVideoProgressbarCreateTimer(pUserData);
 736 }
 737
 738 void MpVideoProgressbarReset(void *pUserData)
 739 {
 740         VideoLogInfo("");
 741
 742         if (!pUserData) {
 743                 VideoLogInfo("[ERR]");
 744                 return;
 745         }
 746
 747         MpVideoProgressbarDeleteTimer();
 748
 749         edje_object_part_drag_value_set(pProgressbarEdj, "progress.playing", 0.0, 0.0);
 750         edje_object_part_text_set(pProgressbarEdj, "progress.txt.played", "00:00:00");
 751 }
 752