src/mp-video-progressbar.c

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