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