src/mp-util-media-service.c

   1 /*
   2  * Copyright (c) [2012] Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18
  19
  20 #include <media_content.h>
  21
  22
  23 #include "mp-video-log.h"
  24 #include "mp-video-value-define.h"
  25 #include "mp-video-type-define.h"
  26 #include "mp-util-media-service.h"
  27 #include "mp-video-string-define.h"
  28
  29
  30
  31 static Eina_List *VideoFolderList = NULL;
  32 static Eina_List *VideoItemList = NULL;
  33 static int nWhatFileType = MP_MEDIA_VIDEO_FILE_TYPE;
  34 static int nTotalVideoTypeFiles = 0;
  35 static int nNumberOfVideoItemByType = 0;
  36
  37
  38 bool MpUtilMediaSvcIs3gpFile(char* szFileUri)
  39 {
  40         VideoLogInfo("");
  41
  42         int nRet = FALSE;
  43         char* szTmpUriPath = szFileUri;
  44
  45         if(szTmpUriPath)
  46         {
  47                 char *szExt = NULL;
  48                 szExt = strrchr(szTmpUriPath, '.');
  49
  50                 if((szExt != NULL) && ((szExt+1) != NULL))
  51                 {
  52                         if(!strcmp(szExt+1, "3gp"))
  53                         {
  54                                 nRet = TRUE;
  55                         }
  56                         else
  57                         {
  58                                 nRet = FALSE;
  59                         }
  60                 }
  61                 else
  62                 {
  63                         VideoLogInfo("No exist extension.");
  64                         nRet = FALSE;
  65                 }
  66         }
  67         else
  68         {
  69                 VideoLogInfo("No exist file uri.");
  70                 nRet = FALSE;
  71         }
  72
  73         return nRet;
  74 }
  75
  76 static bool MpUtilMediaSvcIterateForGetVideoItemCb(media_info_h pVideoItem, void *pUserData)
  77 {
  78         VideoLogInfo("");
  79
  80         media_info_h *pAssignFolderItem = (media_info_h*)pUserData;
  81
  82         if(pVideoItem != NULL)
  83         {
  84                 char *szTmpStr = NULL;
  85                 media_info_clone(pAssignFolderItem, pVideoItem);
  86                 media_info_get_display_name(*pAssignFolderItem, &szTmpStr);
  87                 VideoLogInfo("Display name : %s", szTmpStr);
  88
  89                 if(szTmpStr)
  90                 {
  91                         free(szTmpStr);
  92                 }
  93         }
  94
  95         return FALSE;
  96 }
  97
  98 static bool MpUtilMediaSvcIterateForVideoItemListViewCb(media_info_h pMediaItem, void *pUserData)
  99 {
 100         VideoLogInfo("");
 101
 102         media_info_h pAssignMediaItem = NULL;
 103         media_content_type_e nMediaType = MEDIA_CONTENT_TYPE_OTHERS;
 104
 105         media_info_get_media_type(pMediaItem, &nMediaType);
 106         VideoLogInfo("nMediaType : %d", nMediaType);
 107
 108         if(nMediaType == MEDIA_CONTENT_TYPE_VIDEO)
 109         {
 110                 char *szTmpItemFilePath = NULL;
 111                 char szItemFilePath[STR_LEN_MAX] = {0};
 112
 113                 media_info_get_file_path(pMediaItem, &szTmpItemFilePath);
 114
 115                 if(szTmpItemFilePath == NULL)
 116                 {
 117                         VideoLogInfo("Fail to get file path of media item.");
 118                         return FALSE;
 119                 }
 120                 strncpy(szItemFilePath, szTmpItemFilePath, STR_LEN_MAX - 1);
 121
 122                 free(szTmpItemFilePath);
 123                 szTmpItemFilePath = NULL;
 124
 125                 VideoLogInfo("szItemFilePath : %s", szItemFilePath);
 126
 127                 nTotalVideoTypeFiles++;
 128
 129                 switch(nWhatFileType)
 130                 {
 131                 case MP_MEDIA_VIDEO_FILE_TYPE:
 132                         if(MpUtilMediaSvcIs3gpFile(szItemFilePath) == TRUE)
 133                         {
 134                                 return TRUE;
 135                         }
 136                         break;
 137
 138                 case MP_MEDIA_CAMERA_FILE_TYPE:
 139                         if(MpUtilMediaSvcIs3gpFile(szItemFilePath) == FALSE)
 140                         {
 141                                 return TRUE;
 142                         }
 143                         break;
 144
 145                 case MP_MEDIA_ALL_FILE_TYPE:
 146                         break;
 147                 }
 148
 149                 nNumberOfVideoItemByType++;
 150                 VideoLogInfo("nNumberOfVideoItemByType : %d", nNumberOfVideoItemByType);
 151
 152                 media_info_clone(&pAssignMediaItem, pMediaItem);
 153                 Eina_List **pList = (Eina_List **)pUserData;
 154                 *pList = eina_list_append(*pList, pAssignMediaItem);
 155         }
 156
 157         return TRUE;
 158 }
 159
 160 static bool MpUtilMediaSvcIterateCb(media_info_h pMediaItem, void *pUserData)
 161 {
 162         VideoLogInfo("");
 163
 164         media_info_h pAssignMediaItem = NULL;
 165         media_content_type_e nMediaType = MEDIA_CONTENT_TYPE_OTHERS;
 166
 167         media_info_get_media_type(pMediaItem, &nMediaType);
 168         VideoLogInfo("nMediaType : %d", nMediaType);
 169
 170         if(nMediaType == MEDIA_CONTENT_TYPE_VIDEO)
 171         {
 172                 media_info_clone(&pAssignMediaItem, pMediaItem);
 173                 Eina_List **pList = (Eina_List **)pUserData;
 174                 *pList = eina_list_append(*pList, pAssignMediaItem);
 175
 176                 nTotalVideoTypeFiles++;
 177                 nNumberOfVideoItemByType++;
 178                 VideoLogInfo("nNumberOfVideoItemByType : %d", nNumberOfVideoItemByType);
 179         }
 180
 181         return TRUE;
 182 }
 183
 184 static bool MpUtilMediaSvcIterateForGetFolderCb(media_folder_h pFolderItem, void *pUserData)
 185 {
 186         VideoLogInfo("");
 187
 188         media_folder_h *pAssignFolderItem = (media_folder_h*)pUserData;
 189
 190         if(pFolderItem != NULL)
 191         {
 192                 char *szTmpStr = NULL;
 193                 media_folder_clone(pAssignFolderItem, pFolderItem);
 194                 media_folder_get_name(*pAssignFolderItem, &szTmpStr);
 195                 VideoLogInfo("Folder name : %s", szTmpStr);
 196
 197                 if(szTmpStr)
 198                 {
 199                         free(szTmpStr);
 200                 }
 201         }
 202
 203         return FALSE;
 204 }
 205
 206 static bool MpUtilMediaSvcIterateForFolderListCb(media_folder_h pFolderItem, void *pUserData)
 207 {
 208         VideoLogInfo("");
 209
 210         media_folder_h pAssignFolderItem = NULL;
 211         media_folder_clone(&pAssignFolderItem, pFolderItem);
 212         Eina_List **pList = (Eina_List **)pUserData;
 213         *pList = eina_list_append(*pList, pAssignFolderItem);
 214
 215         return TRUE;
 216 }
 217
 218 static bool MpUtilMediaSvcIterateGetTagCb(media_tag_h pTagItem, void *pUserData)
 219 {
 220         VideoLogInfo("");
 221
 222         media_tag_h *pAssignTagItem = (media_tag_h*)pUserData;
 223
 224         if(!pTagItem)
 225         {
 226                 char *szTmpStr = NULL;
 227                 media_tag_clone(pAssignTagItem, pTagItem);
 228                 media_tag_get_name(*pAssignTagItem, &szTmpStr);
 229                 VideoLogInfo("szTagName : %s", szTmpStr);
 230
 231                 if(szTmpStr)
 232                 {
 233                         free(szTmpStr);
 234                 }
 235         }
 236
 237         return FALSE;
 238 }
 239
 240 static bool MpUtilMediaSvcIterateGetVideoItemOfTagCb(media_info_h media, void *pUserData)
 241 {
 242         VideoLogInfo("");
 243
 244         return TRUE;
 245 }
 246
 247 //
 248 // Internal function
 249 //
 250 bool MpUtilMediaSvcGetFileDirectoryName(char *szFilePath, char *szFileName, char *szDirectoryName, char *szDirectoryPath)
 251 {
 252         VideoLogInfo("");
 253
 254         if(!szFilePath)
 255         {
 256                 VideoLogInfo("[ERR]");
 257                 return FALSE;
 258         }
 259
 260         int nCount = 0;
 261         int nLoopCount = 0;
 262
 263         for(nLoopCount = strlen(szFilePath); nLoopCount >= 0; nLoopCount--)
 264         {
 265                 if (szFilePath[nLoopCount] != '\0')
 266                 {
 267                         nCount++;
 268                 }
 269
 270                 if(szFilePath[nLoopCount] == '/')
 271                 {
 272                         if(szFileName)
 273                         {
 274                                 memcpy(szFileName, &szFilePath[nLoopCount + 1], --nCount);
 275                                 *(szFileName + nCount) = '\0';
 276                                 VideoLogInfo("File name = %s\n", szFileName);
 277                         }
 278
 279                         if(szDirectoryPath)
 280                         {
 281                                 memcpy(szDirectoryPath, &szFilePath[0], nLoopCount);
 282                                 *(szDirectoryPath + nLoopCount + 1) = '\0';
 283                                 VideoLogInfo("Directory path = %s", szDirectoryPath);
 284                         }
 285
 286                         if(szDirectoryName)
 287                         {
 288                                 nCount = 0;
 289                                 for(--nLoopCount; nLoopCount >= 0; nLoopCount--)
 290                                 {
 291                                         nCount++;
 292                                         if(szFilePath[nLoopCount] == '/')
 293                                         {
 294                                                 memcpy(szDirectoryName, &szFilePath[nLoopCount + 1], --nCount);
 295                                                 *(szDirectoryName + nCount) = '\0';
 296                                                 VideoLogInfo("Directory Name = %s", szDirectoryName);
 297
 298                                                 return TRUE;
 299                                         }
 300                                 }
 301                         }
 302
 303                         return TRUE;
 304                 }
 305         }
 306
 307         return FALSE;
 308 }
 309
 310 //
 311 // External function
 312 //
 313
 314 void MpUtilMediaSvcInitSession(void)
 315 {
 316         VideoLogInfo("");
 317
 318         if(media_content_connect() != MEDIA_CONTENT_ERROR_NONE)
 319         {
 320                 VideoLogInfo("Fail to connect to media content db.");
 321         }
 322         else
 323         {
 324                 VideoLogInfo("Success to connect to media content db.");
 325         }
 326 }
 327
 328 void MpUtilMediaSvcFinishSession(void)
 329 {
 330         VideoLogInfo("");
 331
 332         if(media_content_disconnect() != MEDIA_CONTENT_ERROR_NONE)
 333         {
 334                 VideoLogInfo("Fail to disconnect from media content db.");
 335                 return;
 336         }
 337
 338
 339         VideoLogInfo("Success to disconnect from media content db.");
 340         return;
 341 }
 342
 343 bool MpUtilMediaSvcDestoryVideoItemList(void)
 344 {
 345         if(!VideoItemList)
 346         {
 347                 VideoLogInfo("VideoItemList is empty already.");
 348                 return FALSE;
 349         }
 350
 351         media_info_h pTmpVideoItem = NULL;
 352         EINA_LIST_FREE(VideoItemList, pTmpVideoItem)
 353         {
 354                 if(pTmpVideoItem)
 355                 {
 356                         media_info_destroy(pTmpVideoItem);
 357                 }
 358         }
 359
 360         VideoItemList = NULL;
 361
 362         return TRUE;
 363 }
 364
 365 bool MpUtilMediaSvcExtractVideoListFromFolder(char *szFolderPath, int nSortType)
 366 {
 367         if(VideoItemList)
 368         {
 369                 VideoLogInfo("Already exist video list.");
 370                 return FALSE;
 371         }
 372
 373         if(!szFolderPath)
 374         {
 375                 VideoLogInfo("[ERR]");
 376                 return FALSE;
 377         }
 378
 379         VideoLogInfo("");
 380
 381         filter_h m_FilterHandle = NULL;
 382         media_folder_h m_FolderHandle = NULL;
 383         media_content_order_e nOrderType = MEDIA_CONTENT_ORDER_ASC;
 384
 385         char *szFolderID = NULL;
 386         char szTmpStr[STR_LEN_MAX] = {0};
 387         char szOrderObj[STR_LEN_MAX] = {0};
 388
 389         nTotalVideoTypeFiles = 0;
 390         nNumberOfVideoItemByType = 0;
 391
 392         switch(nSortType)
 393         {
 394         case MP_MEDIA_SORT_BY_NONE:
 395         case MP_MEDIA_SORT_BY_NAME_ASC:
 396                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 397                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 398                 break;
 399
 400         case MP_MEDIA_SORT_BY_NAME_DESC:
 401                 nOrderType = MEDIA_CONTENT_ORDER_DESC;
 402                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 403                 break;
 404
 405         case MP_MEDIA_SORT_BY_DATE_MOST_RECENT:
 406                 nOrderType = MEDIA_CONTENT_ORDER_DESC;
 407                 strncpy(szOrderObj, MEDIA_YEAR, STR_LEN_MAX - 1);
 408                 break;
 409
 410         case MP_MEDIA_SORT_BY_OLDEST:
 411                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 412                 strncpy(szOrderObj, MEDIA_YEAR, STR_LEN_MAX - 1);
 413                 break;
 414
 415         default:
 416                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 417                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 418         }
 419
 420         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 421         {
 422                 VideoLogInfo("Fail to create media filter handle.");
 423                 return FALSE;
 424         }
 425
 426         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_TYPE = 1 and FOLDER_PATH = \"%s\"", szFolderPath);
 427         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
 428         {
 429                 VideoLogInfo("Fail to set filter condition.");
 430                 media_filter_destroy(m_FilterHandle);
 431                 return FALSE;
 432         }
 433
 434         if(media_folder_foreach_folder_from_db(m_FilterHandle, MpUtilMediaSvcIterateForGetFolderCb, &m_FolderHandle) != MEDIA_CONTENT_ERROR_NONE)
 435         {
 436                 VideoLogInfo("Fail media_folder_foreach_folder_from_db().");
 437                 media_filter_destroy(m_FilterHandle);
 438                 return FALSE;
 439         }
 440
 441         if(!m_FolderHandle)
 442         {
 443                 VideoLogInfo("Fail to get folder handle.");
 444                 media_filter_destroy(m_FilterHandle);
 445                 return FALSE;
 446         }
 447
 448         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_TYPE = 1");
 449         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
 450         {
 451                 VideoLogInfo("Fail to set filter condition.");
 452                 media_filter_destroy(m_FilterHandle);
 453                 return FALSE;
 454         }
 455
 456         if(media_filter_set_order(m_FilterHandle, nOrderType, szOrderObj, MEDIA_CONTENT_COLLATE_NOCASE) != MEDIA_CONTENT_ERROR_NONE)
 457         {
 458                 VideoLogInfo("Fail to set order.");
 459                 media_filter_destroy(m_FilterHandle);
 460                 return FALSE;
 461         }
 462
 463         if(media_folder_get_folder_id(m_FolderHandle, &szFolderID) != MEDIA_CONTENT_ERROR_NONE)
 464         {
 465                 VideoLogInfo("Fail to get folder id.");
 466                 media_filter_destroy(m_FilterHandle);
 467                 return FALSE;
 468         }
 469
 470         if(media_folder_foreach_media_from_db(szFolderID, m_FilterHandle, MpUtilMediaSvcIterateCb, &VideoItemList) != MEDIA_CONTENT_ERROR_NONE)
 471         {
 472                 VideoLogInfo("Fail to set order.");
 473                 media_filter_destroy(m_FilterHandle);
 474                 return FALSE;
 475         }
 476
 477         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 478         {
 479                 VideoLogInfo("Fail to destroy media filter handle.");
 480         }
 481
 482         if(szFolderID)
 483         {
 484                 free(szFolderID);
 485                 szFolderID = NULL;
 486         }
 487
 488         return TRUE;
 489 }
 490
 491 bool MpUtilMediaSvcExtractVideoListFromAllFolderOfGallery(int nSortType)
 492 {
 493         if(VideoItemList)
 494         {
 495                 VideoLogInfo("Already exist video list.");
 496                 return FALSE;
 497         }
 498
 499         VideoLogInfo("");
 500
 501         filter_h m_FilterHandle = NULL;
 502         media_content_order_e nOrderType = MEDIA_CONTENT_ORDER_ASC;
 503         char szOrderObj[STR_LEN_MAX] = {0};
 504
 505         nTotalVideoTypeFiles = 0;
 506         nNumberOfVideoItemByType = 0;
 507
 508         switch(nSortType)
 509         {
 510         case MP_MEDIA_SORT_BY_NONE:
 511         case MP_MEDIA_SORT_BY_NAME_ASC:
 512                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 513                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 514                 break;
 515
 516         case MP_MEDIA_SORT_BY_NAME_DESC:
 517                 nOrderType = MEDIA_CONTENT_ORDER_DESC;
 518                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 519                 break;
 520
 521         case MP_MEDIA_SORT_BY_DATE_MOST_RECENT:
 522                 nOrderType = MEDIA_CONTENT_ORDER_DESC;
 523                 strncpy(szOrderObj, MEDIA_YEAR, STR_LEN_MAX - 1);
 524                 break;
 525
 526         case MP_MEDIA_SORT_BY_OLDEST:
 527                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 528                 strncpy(szOrderObj, MEDIA_YEAR, STR_LEN_MAX - 1);
 529                 break;
 530
 531         default:
 532                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 533                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 534         }
 535
 536         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 537         {
 538                 VideoLogInfo("Fail to create media filter handle.");
 539                 return FALSE;
 540         }
 541
 542         if(media_filter_set_condition(m_FilterHandle, MEDIA_TYPE" = 1", MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
 543         {
 544                 VideoLogInfo("Fail to set filter condition.");
 545                 media_filter_destroy(m_FilterHandle);
 546                 return FALSE;
 547         }
 548
 549         if(media_filter_set_order(m_FilterHandle, nOrderType, szOrderObj, MEDIA_CONTENT_COLLATE_NOCASE) != MEDIA_CONTENT_ERROR_NONE)
 550         {
 551                 VideoLogInfo("Fail to set order.");
 552                 media_filter_destroy(m_FilterHandle);
 553                 return FALSE;
 554         }
 555
 556         if(media_info_foreach_media_from_db(m_FilterHandle, MpUtilMediaSvcIterateCb, &VideoItemList) != MEDIA_CONTENT_ERROR_NONE)
 557         {
 558                 VideoLogInfo("Fail to get video item list with filter condition.");
 559                 media_filter_destroy(m_FilterHandle);
 560                 return FALSE;
 561         }
 562
 563         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 564         {
 565                 VideoLogInfo("Fail to destroy media filter handle.");
 566                 return FALSE;
 567         }
 568
 569         return TRUE;
 570 }
 571
 572 bool MpUtilMediaSvcExtractVideoListForListView(int nSortType)
 573 {
 574         if(VideoItemList)
 575         {
 576                 VideoLogInfo("Already exist video list.");
 577                 return FALSE;
 578         }
 579
 580         VideoLogInfo("");
 581
 582         filter_h m_FilterHandle = NULL;
 583         media_content_order_e nOrderType = MEDIA_CONTENT_ORDER_ASC;
 584         char szOrderObj[STR_LEN_MAX] = {0};
 585
 586         nTotalVideoTypeFiles = 0;
 587         nNumberOfVideoItemByType = 0;
 588
 589         switch(nSortType)
 590         {
 591         case MP_MEDIA_SORT_BY_NONE:
 592         case MP_MEDIA_SORT_BY_NAME_ASC:
 593                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 594                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 595                 break;
 596
 597         case MP_MEDIA_SORT_BY_NAME_DESC:
 598                 nOrderType = MEDIA_CONTENT_ORDER_DESC;
 599                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 600                 break;
 601
 602         case MP_MEDIA_SORT_BY_DATE_MOST_RECENT:
 603                 nOrderType = MEDIA_CONTENT_ORDER_DESC;
 604                 strncpy(szOrderObj, MEDIA_MODIFIED_TIME, STR_LEN_MAX - 1);
 605                 break;
 606
 607         case MP_MEDIA_SORT_BY_OLDEST:
 608                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 609                 strncpy(szOrderObj, MEDIA_MODIFIED_TIME, STR_LEN_MAX - 1);
 610                 break;
 611
 612         default:
 613                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 614                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 615         }
 616
 617         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 618         {
 619                 VideoLogInfo("Fail to create media filter handle.");
 620                 return FALSE;
 621         }
 622
 623         if(media_filter_set_condition(m_FilterHandle, MEDIA_TYPE" = 1", MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
 624         {
 625                 VideoLogInfo("Fail to set filter condition.");
 626                 media_filter_destroy(m_FilterHandle);
 627                 return FALSE;
 628         }
 629
 630         if(media_filter_set_order(m_FilterHandle, nOrderType, szOrderObj, MEDIA_CONTENT_COLLATE_NOCASE) != MEDIA_CONTENT_ERROR_NONE)
 631         {
 632                 VideoLogInfo("Fail to set order.");
 633                 media_filter_destroy(m_FilterHandle);
 634                 return FALSE;
 635         }
 636
 637         if(media_info_foreach_media_from_db(m_FilterHandle, MpUtilMediaSvcIterateForVideoItemListViewCb, &VideoItemList) != MEDIA_CONTENT_ERROR_NONE)
 638         {
 639                 VideoLogInfo("Fail to get video item list with filter condition.");
 640                 media_filter_destroy(m_FilterHandle);
 641                 return FALSE;
 642         }
 643
 644         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 645         {
 646                 VideoLogInfo("Fail to destroy media filter handle.");
 647                 return FALSE;
 648         }
 649
 650         return TRUE;
 651 }
 652
 653 bool MpUtilMediaSvcExtractVideoListVideoType(int nSortType)
 654 {
 655         VideoLogInfo("");
 656
 657         nWhatFileType = MP_MEDIA_VIDEO_FILE_TYPE;
 658
 659         return MpUtilMediaSvcExtractVideoListForListView(nSortType);
 660 }
 661
 662 bool MpUtilMediaSvcExtractVideoListRecordedType(int nSortType)
 663 {
 664         VideoLogInfo("");
 665
 666         nWhatFileType = MP_MEDIA_CAMERA_FILE_TYPE;
 667
 668         return MpUtilMediaSvcExtractVideoListForListView(nSortType);
 669 }
 670
 671 bool MpUtilMediaSvcExtractVideoListByTagName(char *szTagName)
 672 {
 673         VideoLogInfo("");
 674
 675         if(!szTagName)
 676         {
 677                 VideoLogInfo("[ERR] No Exist tag name.");
 678                 return FALSE;
 679         }
 680
 681         if(VideoItemList)
 682         {
 683                 VideoLogInfo("Already exist video list.");
 684                 return FALSE;
 685         }
 686
 687         VideoLogInfo("szTagName : %s", szTagName);
 688
 689         int nTagID = 0;
 690         char szTmpStr[STR_LEN_MAX] = {0};
 691
 692         media_tag_h pTagHandle = NULL;
 693         filter_h m_FilterHandle = NULL;
 694
 695         nTotalVideoTypeFiles = 0;
 696         nNumberOfVideoItemByType = 0;
 697
 698         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 699         {
 700                 VideoLogInfo("Fail to create media filter handle.");
 701                 return FALSE;
 702         }
 703
 704         //snprintf(szTmpStr, STR_LEN_MAX-1, "TAG_NAME like \"%s\"", szTagName);//snprintf(szTmpStr, STR_LEN_MAX-1, "TAG_NAME like \"\%%s\%\"", szTagName);
 705         snprintf(szTmpStr, STR_LEN_MAX-1, "TAG_NAME like \"%%%s%%\"", szTagName);
 706         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
 707         {
 708                 VideoLogInfo("Fail to set filter condition.");
 709                 if(m_FilterHandle)
 710                 {
 711                         media_filter_destroy(m_FilterHandle);
 712                         m_FilterHandle = NULL;
 713                 }
 714                 return FALSE;
 715         }
 716
 717         if(media_filter_set_order(m_FilterHandle, MEDIA_CONTENT_ORDER_ASC, TAG_NAME, MEDIA_CONTENT_COLLATE_NOCASE) != MEDIA_CONTENT_ERROR_NONE)
 718         {
 719                 VideoLogInfo("Fail to set order.");
 720                 if(m_FilterHandle)
 721                 {
 722                         media_filter_destroy(m_FilterHandle);
 723                         m_FilterHandle = NULL;
 724                 }
 725                 return FALSE;
 726         }
 727
 728         if(media_tag_foreach_tag_from_db(m_FilterHandle, MpUtilMediaSvcIterateGetTagCb, &pTagHandle) != MEDIA_CONTENT_ERROR_NONE)
 729         {
 730                 VideoLogInfo("Fail media_tag_foreach_tag_from_db().");
 731                 if(m_FilterHandle)
 732                 {
 733                         media_filter_destroy(m_FilterHandle);
 734                         m_FilterHandle = NULL;
 735                 }
 736                 return FALSE;
 737         }
 738
 739         if(!pTagHandle)
 740         {
 741                 VideoLogInfo("Fail to get pTagHandle.");
 742                 if(m_FilterHandle)
 743                 {
 744                         media_filter_destroy(m_FilterHandle);
 745                         m_FilterHandle = NULL;
 746                 }
 747                 return FALSE;
 748         }
 749
 750         if(media_tag_get_tag_id(pTagHandle, &nTagID) != MEDIA_CONTENT_ERROR_NONE)
 751         {
 752                 VideoLogInfo("Fail to get tag ID.");
 753                 if(m_FilterHandle)
 754                 {
 755                         media_filter_destroy(m_FilterHandle);
 756                         m_FilterHandle = NULL;
 757                 }
 758                 return FALSE;
 759         }
 760
 761         VideoLogInfo("nTagID : %d", nTagID);
 762
 763         memset(szTmpStr, 0, STR_LEN_MAX);
 764         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_TYPE = 1");
 765         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
 766         {
 767                 VideoLogInfo("Fail to set filter condition.");
 768                 if(m_FilterHandle)
 769                 {
 770                         media_filter_destroy(m_FilterHandle);
 771                         m_FilterHandle = NULL;
 772                 }
 773                 return FALSE;
 774         }
 775
 776         if(media_filter_set_order(m_FilterHandle, MEDIA_CONTENT_ORDER_ASC, MEDIA_TITLE, MEDIA_CONTENT_COLLATE_NOCASE) != MEDIA_CONTENT_ERROR_NONE)
 777         {
 778                 VideoLogInfo("Fail to set order.");
 779                 if(m_FilterHandle)
 780                 {
 781                         media_filter_destroy(m_FilterHandle);
 782                         m_FilterHandle = NULL;
 783                 }
 784                 return FALSE;
 785         }
 786
 787         if(media_tag_foreach_media_from_db(nTagID, m_FilterHandle, MpUtilMediaSvcIterateGetVideoItemOfTagCb, VideoItemList) != MEDIA_CONTENT_ERROR_NONE)
 788         {
 789                 VideoLogInfo("Fail media_tag_foreach_media_from_db().");
 790                 if(m_FilterHandle)
 791                 {
 792                         media_filter_destroy(m_FilterHandle);
 793                         m_FilterHandle = NULL;
 794                 }
 795                 return FALSE;
 796         }
 797         if(m_FilterHandle)
 798         {
 799                 if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 800                 {
 801                         VideoLogInfo("Fail to destroy media filter handle.");
 802                         return FALSE;
 803                 }
 804                 m_FilterHandle = NULL;
 805         }
 806
 807         return TRUE;
 808 }
 809
 810 bool MpUtilMediaSvcExtractVideoListFromFavorite(int nSortType)
 811 {
 812         if(VideoItemList)
 813         {
 814                 VideoLogInfo("Already exist video list.");
 815                 return FALSE;
 816         }
 817
 818         VideoLogInfo("");
 819
 820         filter_h m_FilterHandle = NULL;
 821         media_content_order_e nOrderType = MEDIA_CONTENT_ORDER_ASC;
 822         char szOrderObj[STR_LEN_MAX] = {0};
 823         char szTmpStr[STR_LEN_MAX] = {0};
 824
 825         nWhatFileType = MP_MEDIA_ALL_FILE_TYPE;
 826
 827         nTotalVideoTypeFiles = 0;
 828         nNumberOfVideoItemByType = 0;
 829
 830         switch(nSortType)
 831         {
 832         case MP_MEDIA_SORT_BY_NONE:
 833         case MP_MEDIA_SORT_BY_NAME_ASC:
 834                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 835                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 836                 break;
 837
 838         case MP_MEDIA_SORT_BY_NAME_DESC:
 839                 nOrderType = MEDIA_CONTENT_ORDER_DESC;
 840                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 841                 break;
 842
 843         case MP_MEDIA_SORT_BY_DATE_MOST_RECENT:
 844                 nOrderType = MEDIA_CONTENT_ORDER_DESC;
 845                 strncpy(szOrderObj, MEDIA_YEAR, STR_LEN_MAX - 1);
 846                 break;
 847
 848         case MP_MEDIA_SORT_BY_OLDEST:
 849                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 850                 strncpy(szOrderObj, MEDIA_YEAR, STR_LEN_MAX - 1);
 851                 break;
 852
 853         default:
 854                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
 855                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 856         }
 857
 858         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 859         {
 860                 VideoLogInfo("Fail to create media filter handle.");
 861                 return FALSE;
 862         }
 863
 864         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_TYPE = 1 and MEDIA_FAVOURITE = 1");
 865         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
 866         {
 867                 VideoLogInfo("Fail to set filter condition.");
 868                 media_filter_destroy(m_FilterHandle);
 869                 return FALSE;
 870         }
 871
 872         if(media_filter_set_order(m_FilterHandle, nOrderType, szOrderObj, MEDIA_CONTENT_COLLATE_NOCASE) != MEDIA_CONTENT_ERROR_NONE)
 873         {
 874                 VideoLogInfo("Fail to set order.");
 875                 media_filter_destroy(m_FilterHandle);
 876                 return FALSE;
 877         }
 878
 879         if(media_info_foreach_media_from_db(m_FilterHandle, MpUtilMediaSvcIterateForVideoItemListViewCb, &VideoItemList) != MEDIA_CONTENT_ERROR_NONE)
 880         {
 881                 VideoLogInfo("Fail to get video item list with filter condition.");
 882                 media_filter_destroy(m_FilterHandle);
 883                 return FALSE;
 884         }
 885
 886         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 887         {
 888                 VideoLogInfo("Fail to destroy media filter handle.");
 889                 return FALSE;
 890         }
 891
 892         return TRUE;
 893 }
 894
 895 bool MpUtilMediaSvcExtractVideoListForSearchView(const char *keyword)
 896 {
 897         if(VideoItemList)
 898         {
 899                 VideoLogInfo("Already exist video list.");
 900                 return FALSE;
 901         }
 902
 903         VideoLogInfo("");
 904
 905         filter_h m_FilterHandle = NULL;
 906         media_content_order_e nOrderType = MEDIA_CONTENT_ORDER_ASC;
 907         char szOrderObj[STR_LEN_MAX] = {0};
 908         char szTmpStr[STR_LEN_MAX] = {0};
 909
 910         nWhatFileType = MP_MEDIA_ALL_FILE_TYPE;
 911
 912         nTotalVideoTypeFiles = 0;
 913         nNumberOfVideoItemByType = 0;
 914
 915         nOrderType = MEDIA_CONTENT_ORDER_ASC;
 916         strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
 917
 918         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 919         {
 920                 VideoLogInfo("Fail to create media filter handle.");
 921                 return FALSE;
 922         }
 923
 924         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_TYPE = 1 and MEDIA_TITLE like \"%%%s%%\"", keyword);
 925         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
 926         {
 927                 VideoLogInfo("Fail to set filter condition.");
 928                 media_filter_destroy(m_FilterHandle);
 929                 return FALSE;
 930         }
 931
 932         if(media_filter_set_order(m_FilterHandle, nOrderType, szOrderObj, MEDIA_CONTENT_COLLATE_NOCASE) != MEDIA_CONTENT_ERROR_NONE)
 933         {
 934                 VideoLogInfo("Fail to set order.");
 935                 media_filter_destroy(m_FilterHandle);
 936                 return FALSE;
 937         }
 938
 939         if(media_info_foreach_media_from_db(m_FilterHandle, MpUtilMediaSvcIterateForVideoItemListViewCb, &VideoItemList) != MEDIA_CONTENT_ERROR_NONE)
 940         {
 941                 VideoLogInfo("Fail to get video item list with filter condition.");
 942                 media_filter_destroy(m_FilterHandle);
 943                 return FALSE;
 944         }
 945
 946         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
 947         {
 948                 VideoLogInfo("Fail to destroy media filter handle.");
 949                 return FALSE;
 950         }
 951
 952         return TRUE;
 953 }
 954
 955
 956 void MpUtilMediaSvcDestoryVideoList(void)
 957 {
 958         VideoLogInfo("");
 959
 960         if(VideoFolderList)
 961         {
 962                 MpUtilMediaSvcDestoryVideoFolderList();
 963                 VideoFolderList = NULL;
 964         }
 965
 966         if(VideoItemList)
 967         {
 968                 MpUtilMediaSvcDestoryVideoItemList();
 969                 VideoItemList = NULL;
 970         }
 971
 972         nTotalVideoTypeFiles = 0;
 973         nNumberOfVideoItemByType = 0;
 974 }
 975
 976 bool MpUtilMediaSvcRemoveItemByUrlWithList(char *szFilePath)
 977 {
 978         if(!szFilePath)
 979         {
 980                 VideoLogInfo("[ERR]");
 981                 return FALSE;
 982         }
 983
 984         if(!VideoItemList)
 985         {
 986                 VideoLogInfo("pList is empty already.");
 987                 return FALSE;
 988         }
 989
 990         VideoLogInfo("szFilePath : %s", szFilePath);
 991
 992         char *szGetFilePath = NULL;
 993         media_info_h pItem = NULL;
 994         Eina_List *pIterateList = NULL;
 995         EINA_LIST_FOREACH(VideoItemList, pIterateList, pItem)
 996         {
 997                 if(pItem)
 998                 {
 999                         if(media_info_get_file_path(pItem, &szGetFilePath) == MEDIA_CONTENT_ERROR_NONE)
1000                         {
1001                                 if(szGetFilePath)
1002                                 {
1003                                         if(!strcmp(szGetFilePath, szFilePath))
1004                                         {
1005                                                 VideoLogInfo("Find %s", szGetFilePath);
1006                                                 char *szMediaID = NULL;
1007                                                 media_info_get_media_id(pItem, &szMediaID);
1008                                                 media_info_delete_from_db(szMediaID);
1009                                                 VideoItemList = eina_list_remove(VideoItemList, pItem);
1010                                                 media_info_destroy(pItem);
1011
1012                                                 nNumberOfVideoItemByType--;
1013                                                 VideoLogInfo("nNumberOfVideoItemByType : %d", nNumberOfVideoItemByType);
1014
1015                                                 if(szMediaID)
1016                                                 {
1017                                                         free(szMediaID);
1018                                                 }
1019
1020                                                 if(szGetFilePath)
1021                                                 {
1022                                                         free(szGetFilePath);
1023                                                 }
1024
1025                                                 return TRUE;
1026                                         }
1027                                 }
1028                                 else
1029                                 {
1030                                         VideoLogInfo("No exist %s in media info Database module.", szFilePath);
1031                                         return FALSE;
1032                                 }
1033                         }
1034                 }
1035         }
1036         return FALSE;
1037 }
1038
1039 bool MpUtilMediaSvcRemoveItemByListIndex(int nVideoItemIndex)
1040 {
1041         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1042
1043         if(!VideoItemList)
1044         {
1045                 VideoLogInfo("pList is empty already.");
1046                 return FALSE;
1047         }
1048
1049         media_info_h pItem = eina_list_nth(VideoItemList, nVideoItemIndex);
1050
1051         if(pItem)
1052         {
1053                 char *szMediaID = NULL;
1054                 media_info_get_media_id(pItem, &szMediaID);
1055                 if(szMediaID)
1056                 {
1057                         media_info_delete_from_db(szMediaID);
1058                         VideoItemList = eina_list_remove(VideoItemList, pItem);
1059                         free(szMediaID);
1060                         media_info_destroy(pItem);
1061                         nNumberOfVideoItemByType--;
1062                         VideoLogInfo("nNumberOfVideoItemByType : %d", nNumberOfVideoItemByType);
1063                 }
1064                 else
1065                 {
1066                         VideoLogInfo("No exist media ID in index %d of list.", nVideoItemIndex);
1067                         return FALSE;
1068                 }
1069         }
1070         else
1071         {
1072                 VideoLogInfo("Fail to remove item in media svc and list.");
1073                 return FALSE;
1074         }
1075
1076         return TRUE;
1077 }
1078
1079 bool MpUtilMediaSvcRemoveItemByListIndexWithoutListItem(int nVideoItemIndex)
1080 {
1081         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1082
1083         if(!VideoItemList)
1084         {
1085                 VideoLogInfo("pList is empty already.");
1086                 return FALSE;
1087         }
1088
1089         media_info_h pItem = eina_list_nth(VideoItemList, nVideoItemIndex);
1090
1091         if(pItem)
1092         {
1093                 char *szMediaID = NULL;
1094                 media_info_get_media_id(pItem, &szMediaID);
1095                 if(szMediaID)
1096                 {
1097                         media_info_delete_from_db(szMediaID);
1098                         free(szMediaID);
1099                         nNumberOfVideoItemByType--;
1100                         VideoLogInfo("nNumberOfVideoItemByType : %d", nNumberOfVideoItemByType);
1101                 }
1102                 else
1103                 {
1104                         VideoLogInfo("No exist media ID in index %d of list.", nVideoItemIndex);
1105                         return FALSE;
1106                 }
1107         }
1108         else
1109         {
1110                 VideoLogInfo("Fail to remove item in media svc and list.");
1111                 return FALSE;
1112         }
1113
1114         return TRUE;
1115 }
1116
1117
1118 bool MpUtilMediaSvcGetVideoIDByVideoUri(const char *szPath, char *szVideoID)
1119 {
1120         VideoLogInfo("");
1121
1122         media_info_h pVideoItem = NULL;
1123         filter_h m_FilterHandle = NULL;
1124         char szTmpStr[STR_LEN_MAX] = {0};
1125         bool bRet = FALSE;
1126
1127         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1128         {
1129                 VideoLogInfo("Fail to create media filter handle.");
1130                 bRet = FALSE;
1131         }
1132
1133         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_PATH = \"%s\"", szPath);
1134         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
1135         {
1136                 VideoLogInfo("Fail to set filter condition.");
1137                 media_filter_destroy(m_FilterHandle);
1138                 bRet = FALSE;
1139         }
1140
1141         if(media_info_foreach_media_from_db(m_FilterHandle, MpUtilMediaSvcIterateForGetVideoItemCb, &pVideoItem) != MEDIA_CONTENT_ERROR_NONE)
1142         {
1143                 VideoLogInfo("Fail to get video item list with filter condition.");
1144                 media_filter_destroy(m_FilterHandle);
1145                 bRet = FALSE;
1146         }
1147
1148         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1149         {
1150                 VideoLogInfo("Fail to destroy media filter handle.");
1151                 bRet = FALSE;
1152         }
1153
1154         if(pVideoItem)
1155         {
1156                 char *szMediaID = NULL;
1157                 media_info_get_media_id(pVideoItem, &szMediaID);
1158                 if(szMediaID)
1159                 {
1160                         strncpy(szVideoID, szMediaID, STR_LEN_MAX-2);
1161                         free(szMediaID);
1162                 }
1163                 media_info_destroy(pVideoItem);
1164                 bRet = TRUE;
1165         }
1166         else
1167         {
1168                 bRet = FALSE;
1169         }
1170
1171         return bRet;
1172 }
1173
1174 unsigned int MpUtilMediaSvcGetVideoLastPlayTimeByVideoUri(const char *szPath)
1175 {
1176         if(!szPath)
1177         {
1178                 VideoLogInfo("No exist video path.");
1179                 return 0;
1180         }
1181
1182         VideoLogInfo("szPath : %s", szPath);
1183
1184         time_t LastPlayedTime = 0;
1185         media_info_h pVideoItem = NULL;
1186         filter_h m_FilterHandle = NULL;
1187         char szTmpStr[STR_LEN_MAX] = {0};
1188
1189         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1190         {
1191                 VideoLogInfo("Fail to create media filter handle.");
1192                 return FALSE;
1193         }
1194
1195         //snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_PATH = \"%s\"", szPath);
1196         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_PATH = \"%s\"", szPath);
1197         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
1198         {
1199                 VideoLogInfo("Fail to set filter condition.");
1200                 media_filter_destroy(m_FilterHandle);
1201                 return FALSE;
1202         }
1203
1204         if(media_info_foreach_media_from_db(m_FilterHandle, MpUtilMediaSvcIterateForGetVideoItemCb, &pVideoItem) != MEDIA_CONTENT_ERROR_NONE)
1205         {
1206                 VideoLogInfo("Fail to get video item list with filter condition.");
1207                 media_filter_destroy(m_FilterHandle);
1208                 return FALSE;
1209         }
1210
1211         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1212         {
1213                 VideoLogInfo("Fail to destroy media filter handle.");
1214                 return FALSE;
1215         }
1216
1217         if(pVideoItem)
1218         {
1219                 video_meta_h pVideoMetaHandle = NULL;
1220                 if(media_info_get_video(pVideoItem, &pVideoMetaHandle) == MEDIA_CONTENT_ERROR_NONE)
1221                 {
1222                         char *szTmpStr = NULL;
1223                         video_meta_get_title(pVideoMetaHandle, &szTmpStr);
1224                         if(szTmpStr)
1225                         {
1226                                 VideoLogInfo("Title : %s", szTmpStr);
1227                                 free(szTmpStr);
1228                         }
1229                         else
1230                         {
1231                                 VideoLogInfo("No exist title");
1232                         }
1233
1234                         video_meta_get_played_time(pVideoMetaHandle, &LastPlayedTime);
1235                         VideoLogInfo("Last Played Time : %d", LastPlayedTime);
1236                         video_meta_destroy(pVideoMetaHandle);
1237                 }
1238                 media_info_destroy(pVideoItem);
1239         }
1240
1241         return (unsigned int)LastPlayedTime;
1242 }
1243
1244 unsigned int MpUtilMediaSvcGetVideoDurationByVideoUri(const char *szPath)
1245 {
1246         if(!szPath)
1247         {
1248                 VideoLogInfo("No exist video path.");
1249                 return 0;
1250         }
1251
1252         VideoLogInfo("szPath : %s", szPath);
1253
1254         int nDurationTime = 0;
1255         media_info_h pVideoItem = NULL;
1256         filter_h m_FilterHandle = NULL;
1257         char szTmpStr[STR_LEN_MAX] = {0};
1258
1259         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1260         {
1261                 VideoLogInfo("Fail to create media filter handle.");
1262                 return FALSE;
1263         }
1264
1265         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_PATH = \"%s\"", szPath);
1266         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
1267         {
1268                 VideoLogInfo("Fail to set filter condition.");
1269                 media_filter_destroy(m_FilterHandle);
1270                 return FALSE;
1271         }
1272
1273         if(media_info_foreach_media_from_db(m_FilterHandle, MpUtilMediaSvcIterateForGetVideoItemCb, &pVideoItem) != MEDIA_CONTENT_ERROR_NONE)
1274         {
1275                 VideoLogInfo("Fail to get video item list with filter condition.");
1276                 media_filter_destroy(m_FilterHandle);
1277                 return FALSE;
1278         }
1279
1280         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1281         {
1282                 VideoLogInfo("Fail to destroy media filter handle.");
1283                 return FALSE;
1284         }
1285
1286         if(pVideoItem)
1287         {
1288                 video_meta_h pVideoMetaHandle = NULL;
1289                 if(media_info_get_video(pVideoItem, &pVideoMetaHandle) == MEDIA_CONTENT_ERROR_NONE)
1290                 {
1291                         video_meta_get_duration(pVideoMetaHandle, &nDurationTime);
1292                         VideoLogInfo("Duration time : %d", nDurationTime);
1293                         video_meta_destroy(pVideoMetaHandle);
1294                 }
1295                 media_info_destroy(pVideoItem);
1296         }
1297
1298         return (unsigned int)nDurationTime;
1299 }
1300
1301 int MpUtilMediaSvcGetVideoFilesizeByVideoUri(const char *szPath)
1302 {
1303         if(!szPath)
1304         {
1305                 VideoLogInfo("No exist video path.");
1306                 return 0;
1307         }
1308
1309         VideoLogInfo("szPath : %s", szPath);
1310
1311         unsigned long long nSize = 0;
1312         media_info_h pVideoItem = NULL;
1313         filter_h m_FilterHandle = NULL;
1314         char szTmpStr[STR_LEN_MAX] = {0};
1315
1316         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1317         {
1318                 VideoLogInfo("Fail to create media filter handle.");
1319                 return FALSE;
1320         }
1321
1322         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_PATH = \"%s\"", szPath);
1323         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
1324         {
1325                 VideoLogInfo("Fail to set filter condition.");
1326                 media_filter_destroy(m_FilterHandle);
1327                 return FALSE;
1328         }
1329
1330         if(media_info_foreach_media_from_db(m_FilterHandle, MpUtilMediaSvcIterateForGetVideoItemCb, &pVideoItem) != MEDIA_CONTENT_ERROR_NONE)
1331         {
1332                 VideoLogInfo("Fail to get video item list with filter condition.");
1333                 media_filter_destroy(m_FilterHandle);
1334                 return FALSE;
1335         }
1336
1337         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1338         {
1339                 VideoLogInfo("Fail to destroy media filter handle.");
1340                 return FALSE;
1341         }
1342
1343         if(pVideoItem)
1344         {
1345                 media_info_get_size(pVideoItem, &nSize);
1346                 VideoLogInfo("Video file size time : %d", nSize);
1347                 media_info_destroy(pVideoItem);
1348         }
1349
1350         return nSize;
1351 }
1352
1353 char *MpUtilMediaSvcGetVideoThumbnailByVideoUri(const char *szMediaUri)
1354 {
1355         if(!szMediaUri)
1356         {
1357                 VideoLogInfo("No exist video path.");
1358                 return NULL;
1359         }
1360
1361         VideoLogInfo("szPath : %s", szMediaUri);
1362
1363         media_info_h pVideoItem = NULL;
1364         filter_h m_FilterHandle = NULL;
1365         char *szThumbnailPath = NULL;
1366         char szTmpStr[STR_LEN_MAX] = {0};
1367
1368         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1369         {
1370                 VideoLogInfo("Fail to create media filter handle.");
1371                 return FALSE;
1372         }
1373
1374         memset(szTmpStr, 0, STR_LEN_MAX);
1375         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_PATH = \"%s\"", szMediaUri);
1376         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
1377         {
1378                 VideoLogInfo("Fail to set filter condition.");
1379                 media_filter_destroy(m_FilterHandle);
1380                 return FALSE;
1381         }
1382
1383         if(media_info_foreach_media_from_db(m_FilterHandle, MpUtilMediaSvcIterateForGetVideoItemCb, &pVideoItem) != MEDIA_CONTENT_ERROR_NONE)
1384         {
1385                 VideoLogInfo("Fail to get video item list with filter condition.");
1386                 media_filter_destroy(m_FilterHandle);
1387                 return FALSE;
1388         }
1389
1390         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1391         {
1392                 VideoLogInfo("Fail to destroy media filter handle.");
1393                 return FALSE;
1394         }
1395
1396         if(pVideoItem)
1397         {
1398                 media_info_get_thumbnail_path(pVideoItem, &szThumbnailPath);
1399                 VideoLogInfo("Video thumbnail file path : %s", szThumbnailPath);
1400                 media_info_destroy(pVideoItem);
1401         }
1402
1403         return szThumbnailPath;
1404 }
1405
1406 void MpUtilMediaSvcSetVideoLastPlayedTimeByUri(char* szMediaUri, unsigned int nLastPlayedTime)
1407 {
1408         if(!szMediaUri)
1409         {
1410                 VideoLogInfo("No exist media uri.");
1411                 return;
1412         }
1413
1414         VideoLogInfo("szMediaUri : %s, nLastPlayedTime : %d", szMediaUri, nLastPlayedTime);
1415
1416         time_t LastPlayedTime = (time_t)nLastPlayedTime;
1417         media_info_h pVideoItem = NULL;
1418         filter_h m_FilterHandle = NULL;
1419         char szTmpStr[STR_LEN_MAX] = {0};
1420
1421         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1422         {
1423                 VideoLogInfo("Fail to create media filter handle.");
1424                 return;
1425         }
1426
1427         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_PATH = \"%s\"", szMediaUri);
1428         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
1429         {
1430                 VideoLogInfo("Fail to set filter condition.");
1431                 media_filter_destroy(m_FilterHandle);
1432                 return;
1433         }
1434
1435         if(media_info_foreach_media_from_db(m_FilterHandle, MpUtilMediaSvcIterateForGetVideoItemCb, &pVideoItem) != MEDIA_CONTENT_ERROR_NONE)
1436         {
1437                 VideoLogInfo("Fail to get video item list with filter condition.");
1438                 media_filter_destroy(m_FilterHandle);
1439                 return;
1440         }
1441
1442         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
1443         {
1444                 VideoLogInfo("Fail to destroy media filter handle.");
1445                 return;
1446         }
1447
1448         video_meta_h pVideoMetaHandle = NULL;
1449
1450         if(pVideoItem)
1451         {
1452                 if(media_info_get_video(pVideoItem, &pVideoMetaHandle) != MEDIA_CONTENT_ERROR_NONE)
1453                 {
1454                         VideoLogInfo("Fail to get pVideoMetaHandle.");
1455                 }
1456                 else
1457                 {
1458                         if(pVideoMetaHandle)
1459                         {
1460                                 char *szTmpStr = NULL;
1461                                 video_meta_get_title(pVideoMetaHandle, &szTmpStr);
1462                                 if(szTmpStr)
1463                                 {
1464                                         VideoLogInfo("Title : %s", szTmpStr);
1465                                         free(szTmpStr);
1466                                 }
1467                                 else
1468                                 {
1469                                         VideoLogInfo("No exist title");
1470                                 }
1471
1472                                 video_meta_set_played_time(pVideoMetaHandle, LastPlayedTime);
1473                                 video_meta_update_to_db(pVideoMetaHandle);
1474                                 video_meta_destroy(pVideoMetaHandle);
1475                                 VideoLogInfo("Last Played Time : %d", LastPlayedTime);
1476                         }
1477                         else
1478                         {
1479                                 VideoLogInfo("No exist pVideoMetaHandle");
1480                         }
1481                 }
1482                 media_info_destroy(pVideoItem);
1483         }
1484 }
1485
1486 bool MpUtilMediaSvcGetVideoCurrentUrlPreNextItem(char *szCurrMediaUri, char *szPreMediaUri, char *szNextMediaUri, bool bLoop)
1487 {
1488         VideoLogInfo("");
1489
1490         if(!szCurrMediaUri)
1491         {
1492                 VideoLogInfo("[ERR] No exist current file path.");
1493                 return FALSE;
1494         }
1495
1496         if(!VideoItemList)
1497         {
1498                 VideoLogInfo("No exist VideoItemList.");
1499                 if(bLoop)
1500                 {
1501                         strncpy(szNextMediaUri, szCurrMediaUri, (sizeof(char) * STR_LEN_MAX) - 1);
1502                 }
1503                 return FALSE;
1504         }
1505
1506         int nCount = 0;
1507         int nListSize = 0;
1508         media_info_h pVideoItem = NULL;
1509         Eina_List *pIterateList = NULL;
1510
1511         memset(szPreMediaUri, 0, sizeof(char) * STR_LEN_MAX);
1512         memset(szNextMediaUri, 0, sizeof(char) * STR_LEN_MAX);
1513
1514         nListSize = eina_list_count(VideoItemList);
1515
1516         if(nListSize <= 1)
1517         {
1518                 VideoLogInfo("Video list size == 1.");
1519                 return FALSE;
1520         }
1521
1522         EINA_LIST_FOREACH(VideoItemList, pIterateList, pVideoItem)
1523         {
1524                 if(pVideoItem == NULL)
1525                 {
1526                         continue;
1527                 }
1528
1529                 char *szVideoItemFilePath = NULL;
1530                 media_info_get_file_path(pVideoItem, &szVideoItemFilePath);
1531                 if(szVideoItemFilePath)
1532                 {
1533                         VideoLogInfo("URL of the File item - %s (%d / %d)", szVideoItemFilePath, nCount, nListSize);
1534                         if(!strcmp(szVideoItemFilePath, szCurrMediaUri))
1535                         {
1536                                 free(szVideoItemFilePath);
1537                                 szVideoItemFilePath = NULL;
1538
1539                                 pVideoItem = NULL;
1540                                 pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nCount - 1);
1541                                 if(pVideoItem)
1542                                 {
1543                                         media_info_get_file_path(pVideoItem, &szVideoItemFilePath);
1544                                         strncpy(szPreMediaUri, szVideoItemFilePath, (sizeof(char) * STR_LEN_MAX) - 1);
1545
1546                                         free(szVideoItemFilePath);
1547                                         szVideoItemFilePath = NULL;
1548                                 }
1549                                 else if(bLoop)
1550                                 {
1551                                         media_info_h m_LastItem = (media_info_h)eina_list_nth(VideoItemList, nListSize - 1);
1552                                         VideoLogError("%p", m_LastItem);
1553                                         if(m_LastItem)
1554                                         {
1555                                                 media_info_get_file_path(m_LastItem, &szVideoItemFilePath);
1556                                                 strncpy(szPreMediaUri, szVideoItemFilePath, (sizeof(char) * STR_LEN_MAX) - 1);
1557
1558                                                 free(szVideoItemFilePath);
1559                                                 szVideoItemFilePath = NULL;
1560                                         }
1561                                         m_LastItem = NULL;
1562                                 }
1563
1564                                 pVideoItem = NULL;
1565                                 pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nCount + 1);
1566                                 if(pVideoItem)
1567                                 {
1568                                         media_info_get_file_path(pVideoItem, &szVideoItemFilePath);
1569                                         strncpy(szNextMediaUri, szVideoItemFilePath, (sizeof(char) * STR_LEN_MAX) - 1);
1570
1571                                         free(szVideoItemFilePath);
1572                                         szVideoItemFilePath = NULL;
1573                                 }
1574                                 else if(bLoop)
1575                                 {
1576                                         media_info_h m_FirstItem = (media_info_h)eina_list_nth(VideoItemList, 0);
1577                                         if(m_FirstItem)
1578                                         {
1579                                                 media_info_get_file_path(m_FirstItem, &szVideoItemFilePath);
1580                                                 strncpy(szNextMediaUri, szVideoItemFilePath, (sizeof(char) * STR_LEN_MAX) - 1);
1581
1582                                                 free(szVideoItemFilePath);
1583                                                 szVideoItemFilePath = NULL;
1584                                         }
1585                                         m_FirstItem = NULL;
1586                                 }
1587
1588                                 VideoLogInfo("PreMediaUri:%s", szPreMediaUri);
1589                                 VideoLogInfo("NextMediaUri:%s", szNextMediaUri);
1590
1591                                 return TRUE;
1592                         }
1593                 }
1594
1595                 ++nCount;
1596         }
1597
1598         return FALSE;
1599 }
1600
1601 char* MpUtilMediaSvcGetVideoUrl(const int nVideoItemIndex)
1602 {
1603         if(!VideoItemList)
1604         {
1605                 VideoLogInfo("Not exist video item list handle.");
1606                 return 0;
1607         }
1608
1609         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1610
1611         if(nVideoItemIndex < 0 || nVideoItemIndex >= MpUtilMediaSvcGetVideoListSizeForCheckingIndex())
1612         {
1613                 VideoLogInfo("Error number of list item.");
1614                 return NULL;
1615         }
1616
1617         char *szVideoItemFilePath = NULL;
1618         media_info_h pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nVideoItemIndex);
1619
1620         if(pVideoItem)
1621         {
1622                 media_info_get_file_path(pVideoItem, &szVideoItemFilePath);
1623                 VideoLogInfo("szVideoItemFilePath : %s", szVideoItemFilePath);
1624         }
1625
1626         return szVideoItemFilePath;
1627 }
1628
1629 char* MpUtilMediaSvcGetVideoThumbnail(const int nVideoItemIndex)
1630 {
1631         if(!VideoItemList)
1632         {
1633                 VideoLogInfo("Not exist video item list handle.");
1634                 return 0;
1635         }
1636
1637         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1638
1639         if(nVideoItemIndex < 0 || nVideoItemIndex >= MpUtilMediaSvcGetVideoListSizeForCheckingIndex())
1640         {
1641                 VideoLogInfo("Error number of list item.");
1642                 return NULL;
1643         }
1644
1645         char *szVideoItemThumbnailPath = NULL;
1646         media_info_h pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nVideoItemIndex);
1647
1648         if(pVideoItem)
1649         {
1650                 media_info_get_thumbnail_path(pVideoItem, &szVideoItemThumbnailPath);
1651                 VideoLogInfo("szVideoItemFilePath : %s", szVideoItemThumbnailPath);
1652         }
1653
1654         return szVideoItemThumbnailPath;
1655 }
1656
1657 char* MpUtilMediaSvcGetVideoTitle(const int nVideoItemIndex)
1658 {
1659         if(!VideoItemList)
1660         {
1661                 VideoLogInfo("Not exist video item list handle.");
1662                 return 0;
1663         }
1664
1665         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1666
1667         if(nVideoItemIndex < 0 || nVideoItemIndex >= MpUtilMediaSvcGetVideoListSizeForCheckingIndex())
1668         {
1669                 VideoLogInfo("Error number of list item.");
1670                 return NULL;
1671         }
1672
1673         char *szTitle = NULL;
1674         media_info_h pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nVideoItemIndex);
1675
1676         if(pVideoItem)
1677         {
1678                 media_info_get_display_name(pVideoItem, &szTitle);
1679                 VideoLogInfo("szTitle : %s", szTitle);
1680         }
1681
1682         return szTitle;
1683 }
1684
1685 int MpUtilMediaSvcGetVideoDurationTime(const int nVideoItemIndex)
1686 {
1687         if(!VideoItemList)
1688         {
1689                 VideoLogInfo("Not exist video item list handle.");
1690                 return 0;
1691         }
1692
1693         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1694
1695         if(nVideoItemIndex < 0 || nVideoItemIndex >= MpUtilMediaSvcGetVideoListSizeForCheckingIndex())
1696         {
1697                 VideoLogInfo("Error number of list item.");
1698                 return 0;
1699         }
1700
1701         int nDurationTime = 0;
1702         media_info_h pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nVideoItemIndex);
1703
1704         if(pVideoItem)
1705         {
1706                 video_meta_h pVideoMetaHandle = NULL;
1707                 if(media_info_get_video(pVideoItem, &pVideoMetaHandle) == MEDIA_CONTENT_ERROR_NONE)
1708                 {
1709                         video_meta_get_duration(pVideoMetaHandle, &nDurationTime);
1710                         VideoLogInfo("Duratiob time : %d", nDurationTime);
1711                         video_meta_destroy(pVideoMetaHandle);
1712                 }
1713         }
1714
1715         return nDurationTime;
1716 }
1717
1718 int MpUtilMediaSvcGetVideoLastPlayedPos(const int nVideoItemIndex)
1719 {
1720         if(!VideoItemList)
1721         {
1722                 VideoLogInfo("Not exist video item list handle.");
1723                 return 0;
1724         }
1725
1726         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1727
1728         time_t nLastPlayedTime = 0;
1729         media_info_h pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nVideoItemIndex);
1730
1731         if(pVideoItem)
1732         {
1733                 video_meta_h pVideoMetaHandle = NULL;
1734                 if(media_info_get_video(pVideoItem, &pVideoMetaHandle) == MEDIA_CONTENT_ERROR_NONE)
1735                 {
1736                         video_meta_get_played_time(pVideoMetaHandle, &nLastPlayedTime);
1737                         VideoLogInfo("Last Play time : %d", nLastPlayedTime);
1738                         video_meta_destroy(pVideoMetaHandle);
1739                 }
1740         }
1741
1742         return (int)nLastPlayedTime;
1743 }
1744
1745 int MpUtilMediaSvcGetVideoItemSize(const int nVideoItemIndex)
1746 {
1747         if(!VideoItemList)
1748         {
1749                 VideoLogInfo("Not exist video item list handle.");
1750                 return 0;
1751         }
1752
1753         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1754
1755         unsigned long long nSize = 0;
1756         media_info_h pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nVideoItemIndex);
1757         if(pVideoItem)
1758         {
1759                 media_info_get_size(pVideoItem, &nSize);
1760                 VideoLogInfo("Video file size time : %d", nSize);
1761         }
1762
1763         return nSize;
1764 }
1765
1766 int MpUtilMediaSvcGetVideoItemWidth(const int nVideoItemIndex)
1767 {
1768         if(!VideoItemList)
1769         {
1770                 VideoLogInfo("Not exist video item list handle.");
1771                 return 0;
1772         }
1773
1774         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1775
1776         int nWidth = 0;
1777         media_info_h pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nVideoItemIndex);
1778         video_meta_h pVideoMetaHandle = NULL;
1779
1780         if(pVideoItem)
1781         {
1782                 if(media_info_get_video(pVideoItem, &pVideoMetaHandle) != MEDIA_CONTENT_ERROR_NONE)
1783                 {
1784                         VideoLogInfo("Fail to get pVideoMetaHandle.");
1785                 }
1786                 else
1787                 {
1788                         if(pVideoMetaHandle)
1789                         {
1790                                 char *szTmpStr = NULL;
1791                                 video_meta_get_title(pVideoMetaHandle, &szTmpStr);
1792                                 if(szTmpStr)
1793                                 {
1794                                         VideoLogInfo("Title : %s", szTmpStr);
1795                                         free(szTmpStr);
1796                                 }
1797                                 else
1798                                 {
1799                                         VideoLogInfo("No exist title");
1800                                 }
1801
1802                                 video_meta_get_width(pVideoMetaHandle, &nWidth);
1803                                 video_meta_destroy(pVideoMetaHandle);
1804                                 VideoLogInfo("Video Width : %f", nWidth);
1805                         }
1806                         else
1807                         {
1808                                 VideoLogInfo("No exist pVideoMetaHandle");
1809                         }
1810                 }
1811         }
1812
1813         return nWidth;
1814 }
1815
1816 int MpUtilMediaSvcGetVideoItemHeight(const int nVideoItemIndex)
1817 {
1818         if(!VideoItemList)
1819         {
1820                 VideoLogInfo("Not exist video item list handle.");
1821                 return 0;
1822         }
1823
1824         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1825
1826         int nHeight = 0;
1827         media_info_h pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nVideoItemIndex);
1828         video_meta_h pVideoMetaHandle = NULL;
1829
1830         if(pVideoItem)
1831         {
1832                 if(media_info_get_video(pVideoItem, &pVideoMetaHandle) != MEDIA_CONTENT_ERROR_NONE)
1833                 {
1834                         VideoLogInfo("Fail to get pVideoMetaHandle.");
1835                 }
1836                 else
1837                 {
1838                         if(pVideoMetaHandle)
1839                         {
1840                                 char *szTmpStr = NULL;
1841                                 video_meta_get_title(pVideoMetaHandle, &szTmpStr);
1842                                 if(szTmpStr)
1843                                 {
1844                                         VideoLogInfo("Title : %s", szTmpStr);
1845                                         free(szTmpStr);
1846                                 }
1847                                 else
1848                                 {
1849                                         VideoLogInfo("No exist title");
1850                                 }
1851
1852                                 video_meta_get_height(pVideoMetaHandle, &nHeight);
1853                                 video_meta_destroy(pVideoMetaHandle);
1854                                 VideoLogInfo("Video Width : %f", nHeight);
1855                         }
1856                         else
1857                         {
1858                                 VideoLogInfo("No exist pVideoMetaHandle");
1859                         }
1860                 }
1861         }
1862
1863         return nHeight;
1864 }
1865
1866 time_t MpUtilMediaSvcGetVideoItemDateTime(const int nVideoItemIndex)
1867 {
1868         if(!VideoItemList)
1869         {
1870                 VideoLogInfo("Not exist video item list handle.");
1871                 return 0;
1872         }
1873
1874         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1875
1876         time_t nDateTime = 0;
1877         media_info_h pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nVideoItemIndex);
1878         if(pVideoItem)
1879         {
1880                 media_info_get_modified_time(pVideoItem, &nDateTime);
1881                 VideoLogInfo("Video date time : %d", nDateTime);
1882         }
1883
1884         return nDateTime;
1885 }
1886
1887 char *MpUtilMediaSvcGetVideoItemExtension(const int nVideoItemIndex)
1888 {
1889         if(!VideoItemList)
1890         {
1891                 VideoLogInfo("Not exist video item list handle.");
1892                 return 0;
1893         }
1894
1895         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1896
1897         return NULL;
1898 }
1899
1900 double MpUtilMediaSvcGetVideoItemLongitude(const int nVideoItemIndex)
1901 {
1902         if(!VideoItemList)
1903         {
1904                 VideoLogInfo("Not exist video item list handle.");
1905                 return 0;
1906         }
1907
1908         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1909
1910         double nLongitude = 0;
1911         media_info_h pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nVideoItemIndex);
1912         if(pVideoItem)
1913         {
1914                 media_info_get_longitude(pVideoItem, &nLongitude);
1915                 VideoLogInfo("nLongitude : %f", nLongitude);
1916         }
1917
1918         return nLongitude;
1919 }
1920
1921 double MpUtilMediaSvcGetVideoItemLatitude(const int nVideoItemIndex)
1922 {
1923         if(!VideoItemList)
1924         {
1925                 VideoLogInfo("Not exist video item list handle.");
1926                 return 0;
1927         }
1928
1929         VideoLogInfo("nVideoItemIndex : %d", nVideoItemIndex);
1930
1931         double nLatitude = 0;
1932         media_info_h pVideoItem = (media_info_h)eina_list_nth(VideoItemList, nVideoItemIndex);
1933         if(pVideoItem)
1934         {
1935                 media_info_get_latitude(pVideoItem, &nLatitude);
1936                 VideoLogInfo("nLongitude : %f", nLatitude);
1937         }
1938
1939         return nLatitude;
1940 }
1941
1942
1943
1944
1945 int MpUtilMediaSvcGetVideoListSizeForCheckingIndex(void)
1946 {
1947         if(!VideoItemList)
1948         {
1949                 VideoLogInfo("Not exist video item list handle.");
1950                 return 0;
1951         }
1952
1953         VideoLogInfo("");
1954
1955         return (int)eina_list_count(VideoItemList);
1956 }
1957
1958 int MpUtilMediaSvcGetNumberOfVideoItemByType(void)
1959 {
1960         VideoLogInfo("nNumberOfVideoItemByType : %d", nNumberOfVideoItemByType);
1961
1962         return nNumberOfVideoItemByType;
1963 }
1964
1965 int MpUtilMediaSvcGetTotalVideoTypeFiles(void)
1966 {
1967         VideoLogInfo("nTotalVideoTypeFiles : %d", nTotalVideoTypeFiles);
1968
1969         return (int)nTotalVideoTypeFiles;
1970 }
1971
1972 void* MpUtilMediaSvcGetVideoitem(const int nVideoItemIndex)
1973 {
1974         if(!VideoItemList)
1975         {
1976                 VideoLogInfo("Not exist video item list handle.");
1977                 return NULL;
1978         }
1979
1980         if(nVideoItemIndex < 0 || nVideoItemIndex >= MpUtilMediaSvcGetVideoListSizeForCheckingIndex())
1981         {
1982                 VideoLogInfo("Error number of list item.");
1983                 return NULL;
1984         }
1985
1986         VideoLogInfo("");
1987
1988         return (void*)eina_list_nth(VideoItemList, nVideoItemIndex);
1989 }
1990
1991 void MpUtilMediaSvcPrintListInfo(void)
1992 {
1993         if(!VideoItemList)
1994         {
1995                 VideoLogInfo("Not exist video item list handle.");
1996                 return;
1997         }
1998
1999         VideoLogInfo("List size : %d", MpUtilMediaSvcGetNumberOfVideoItemByType());
2000
2001         media_info_h pVideoItem = NULL;
2002         Eina_List *pIterateList = NULL;
2003         int nCounter = 0;
2004         EINA_LIST_FOREACH(VideoItemList, pIterateList, pVideoItem)
2005         {
2006                 if(pVideoItem)
2007                 {
2008                         char *szTitle = NULL;
2009                         media_info_get_display_name(pVideoItem, &szTitle);
2010                         if(szTitle)
2011                         {
2012                                 VideoLogInfo("%d - Print title of all list items : %s", nCounter, szTitle);
2013                                 free(szTitle);
2014                         }
2015                         else
2016                         {
2017                                 VideoLogInfo("%d - Print title of all list items : NULL.", nCounter);
2018                         }
2019                         nCounter++;
2020                 }
2021         }
2022 }
2023
2024 int MpUtilMediaSvcFindVideoItemIndexByUrl(const char *szPath)
2025 {
2026         if(!VideoItemList || !szPath)
2027         {
2028                 VideoLogInfo("[ERR] No exist VideoItemList or szPath.");
2029                 return 99999;
2030         }
2031
2032         VideoLogInfo("");
2033
2034         unsigned int nCounter = 0;
2035
2036         Eina_List *pCurList = NULL;
2037         media_info_h pVideoItem = NULL;
2038
2039         EINA_LIST_FOREACH(VideoItemList, pCurList, pVideoItem)
2040         {
2041                 if(pVideoItem)
2042                 {
2043                         char *szTitle = NULL;
2044                         media_info_get_display_name(pVideoItem, &szTitle);
2045                         VideoLogInfo("szTitle : %s", szTitle);
2046
2047                         if(!strcmp(szTitle , szPath))
2048                         {
2049                                 VideoLogInfo("Find same file url. index : %d", nCounter);
2050                                 free(szTitle);
2051                                 return nCounter;
2052                         }
2053                         free(szTitle);
2054                 }
2055
2056                 nCounter++;
2057         }
2058
2059         return 99999;
2060 }
2061
2062 bool MpUtilMediaSvcExtractVideoFolderList(int nSortType)
2063 {
2064         VideoLogInfo("");
2065
2066         filter_h m_FilterHandle = NULL;
2067         media_content_order_e nOrderType = MEDIA_CONTENT_ORDER_ASC;
2068
2069         char szTmpStr[STR_LEN_MAX] = {0};
2070         char szOrderObj[STR_LEN_MAX] = {0};
2071
2072         switch(nSortType)
2073         {
2074         case MP_MEDIA_SORT_BY_NONE:
2075         case MP_MEDIA_SORT_BY_NAME_ASC:
2076                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
2077                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
2078                 break;
2079
2080         case MP_MEDIA_SORT_BY_NAME_DESC:
2081                 nOrderType = MEDIA_CONTENT_ORDER_DESC;
2082                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
2083                 break;
2084
2085         case MP_MEDIA_SORT_BY_DATE_MOST_RECENT:
2086                 nOrderType = MEDIA_CONTENT_ORDER_DESC;
2087                 strncpy(szOrderObj, MEDIA_YEAR, STR_LEN_MAX - 1);
2088                 break;
2089
2090         case MP_MEDIA_SORT_BY_OLDEST:
2091                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
2092                 strncpy(szOrderObj, MEDIA_YEAR, STR_LEN_MAX - 1);
2093                 break;
2094
2095         default:
2096                 nOrderType = MEDIA_CONTENT_ORDER_ASC;
2097                 strncpy(szOrderObj, MEDIA_TITLE, STR_LEN_MAX - 1);
2098         }
2099
2100         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
2101         {
2102                 VideoLogInfo("Fail to create media filter handle.");
2103                 return FALSE;
2104         }
2105
2106         snprintf(szTmpStr, STR_LEN_MAX, "MEDIA_TYPE = 1");
2107         if(media_filter_set_condition(m_FilterHandle, szTmpStr, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
2108         {
2109                 VideoLogInfo("Fail to set filter condition.");
2110                 media_filter_destroy(m_FilterHandle);
2111                 return FALSE;
2112         }
2113
2114         if(media_folder_foreach_folder_from_db(m_FilterHandle, MpUtilMediaSvcIterateForFolderListCb, &VideoFolderList) != MEDIA_CONTENT_ERROR_NONE)
2115         {
2116                 VideoLogInfo("Fail media_folder_foreach_folder_from_db().");
2117                 media_filter_destroy(m_FilterHandle);
2118                 return FALSE;
2119         }
2120
2121         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
2122         {
2123                 VideoLogInfo("Fail to destroy media filter handle.");
2124         }
2125
2126         return TRUE;
2127 }
2128
2129 bool MpUtilMediaSvcDestoryVideoFolderList(void)
2130 {
2131         if(!VideoFolderList)
2132         {
2133                 VideoLogInfo("VideoFolderList is empty already.");
2134                 return FALSE;
2135         }
2136
2137         media_folder_h pTmpFolderItem = NULL;
2138         EINA_LIST_FREE(VideoFolderList, pTmpFolderItem)
2139         {
2140                 if(pTmpFolderItem)
2141                 {
2142                         media_folder_destroy(pTmpFolderItem);
2143                 }
2144         }
2145
2146         VideoFolderList = NULL;
2147
2148         return TRUE;
2149 }
2150
2151 int MpUtilMediaSvcGetVideoFolderListSize(void)
2152 {
2153         if(!VideoFolderList)
2154         {
2155                 VideoLogInfo("Not exist video item list handle.");
2156                 return 0;
2157         }
2158
2159         VideoLogInfo("");
2160
2161         if(VideoFolderList)
2162         {
2163                 return (int)eina_list_count(VideoFolderList);
2164         }
2165
2166         return 0;
2167 }
2168
2169 char* MpUtilMediaSvcGetVideoFolderName(int nVideoFolderIndex)
2170 {
2171         if(!VideoFolderList)
2172         {
2173                 VideoLogInfo("Not exist video folder list handle.");
2174                 return 0;
2175         }
2176
2177         VideoLogInfo("nVideoItemIndex : %d", nVideoFolderIndex);
2178
2179         if(nVideoFolderIndex < 0 || nVideoFolderIndex >= MpUtilMediaSvcGetVideoFolderListSize())
2180         {
2181                 VideoLogInfo("Error number of list item.");
2182                 return NULL;
2183         }
2184
2185         char *szFolderName = NULL;
2186         media_folder_h pFolderItem = (media_folder_h)eina_list_nth(VideoFolderList, nVideoFolderIndex);
2187         if(pFolderItem)
2188         {
2189                 media_folder_get_name(pFolderItem, &szFolderName);
2190
2191                 if(szFolderName)
2192                 {
2193                         VideoLogInfo("szFolderName : %s", szFolderName);
2194                         return szFolderName;
2195                 }
2196         }
2197
2198         return NULL;
2199 }
2200
2201 char* MpUtilMediaSvcGetVideoFolderUrl(int nVideoFolderIndex)
2202 {
2203         if(!VideoFolderList)
2204         {
2205                 VideoLogInfo("Not exist video item list handle.");
2206                 return 0;
2207         }
2208
2209         VideoLogInfo("nVideoItemIndex : %d", nVideoFolderIndex);
2210
2211         if(nVideoFolderIndex < 0 || nVideoFolderIndex >= MpUtilMediaSvcGetVideoFolderListSize())
2212         {
2213                 VideoLogInfo("Error number of list item.");
2214                 return NULL;
2215         }
2216
2217         char *szFolderPath = NULL;
2218         media_folder_h pFolderItem = (media_folder_h)eina_list_nth(VideoFolderList, nVideoFolderIndex);
2219         if(pFolderItem)
2220         {
2221                 media_folder_get_path(pFolderItem, &szFolderPath);
2222
2223                 if(szFolderPath)
2224                 {
2225                         VideoLogInfo("szFolderPath : %s", szFolderPath);
2226                         return szFolderPath;
2227                 }
2228         }
2229
2230         return NULL;
2231 }
2232
2233 static bool MpUtilMediaSvcBookmarkItemCb(media_bookmark_h pBookmark, void *pUserData)
2234 {
2235         VideoLogInfo("");
2236
2237         media_bookmark_h pAssignBookmark = NULL;
2238         media_bookmark_clone(&pAssignBookmark, pBookmark);
2239
2240         GList **pList = (GList**)pUserData;
2241         *pList = g_list_append(*pList, pAssignBookmark);
2242
2243         return TRUE;
2244 }
2245
2246 bool MpUtilMediaSvcBookmarkListGet(char *vid, GList **list)
2247 {
2248         if(!vid)
2249         {
2250                 VideoLogInfo("No exist vid.");
2251                 return FALSE;
2252         }
2253
2254         if(!list)
2255         {
2256                 VideoLogInfo("No exist list.");
2257                 return FALSE;
2258         }
2259
2260         VideoLogInfo("vid : %s", vid);
2261
2262         filter_h m_FilterHandle = NULL;
2263
2264         if(media_filter_create(&m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
2265         {
2266                 VideoLogInfo("Fail to create media filter handle.");
2267                 return FALSE;
2268         }
2269
2270         if(media_filter_set_order(m_FilterHandle, MEDIA_CONTENT_ORDER_ASC, BOOKMARK_MARKED_TIME, MEDIA_CONTENT_COLLATE_DEFAULT) != MEDIA_CONTENT_ERROR_NONE)
2271         {
2272                 VideoLogInfo("Fail to set order.");
2273                 media_filter_destroy(m_FilterHandle);
2274                 return FALSE;
2275         }
2276
2277         if(media_info_foreach_bookmark_from_db(vid, m_FilterHandle, MpUtilMediaSvcBookmarkItemCb, list) != MEDIA_CONTENT_ERROR_NONE)
2278         {
2279                 VideoLogInfo("Fail to get bookmark of video item with filter condition.");
2280                 media_filter_destroy(m_FilterHandle);
2281                 return FALSE;
2282         }
2283
2284         if(media_filter_destroy(m_FilterHandle) != MEDIA_CONTENT_ERROR_NONE)
2285         {
2286                 VideoLogInfo("Fail to destroy media filter handle.");
2287                 return FALSE;
2288         }
2289
2290         return TRUE;
2291 }
2292
2293 void MpUtilMediaSvcBookmarkListClear(GList *pList)
2294 {
2295         VideoLogInfo("");
2296
2297         if(pList == NULL)
2298         {
2299                 VideoLogInfo("list == NULL\n");
2300                 return;
2301         }
2302
2303         media_bookmark_h pBookmarkItem = NULL;
2304
2305         int nCount = 0;
2306         int i = 0;
2307
2308         nCount = g_list_length(pList);
2309         for(i = 0; i < nCount; i++)
2310         {
2311                 pBookmarkItem = (void *)g_list_nth_data(pList, i);
2312                 if(pBookmarkItem)
2313                 {
2314                         media_bookmark_destroy(pBookmarkItem);
2315                         pBookmarkItem = NULL;
2316                 }
2317         }
2318
2319         g_list_free(pList);
2320 }
2321
2322 int MpUtilMediaSvcBookmarkInsert(char *vid, int position, char *path)
2323 {
2324         VideoLogInfo("");
2325         int ret = 0;
2326
2327         if(vid < 0 || path == NULL)
2328         {
2329                 VideoLogInfo("Invalid Parameter : %d, %s", vid, path);
2330                 return -1;
2331         }
2332
2333         if(media_bookmark_insert_to_db(vid, position, path) != MEDIA_CONTENT_ERROR_NONE)
2334         {
2335                 VideoLogInfo("minfo_add_bookmark ERR : %d", ret);
2336                 return -1;
2337         }
2338
2339         return 0;
2340 }
2341
2342 int MpUtilMediaSvcBookmarkDelete(char *vid, int position)
2343 {
2344         VideoLogInfo("");
2345         bool ret = 0;
2346
2347         int bookmarkid = 0;
2348         char *path = NULL;
2349
2350         GList *list = NULL;
2351         media_bookmark_h data = NULL;
2352         Eina_List *l = NULL;
2353
2354         ret = MpUtilMediaSvcBookmarkListGet(vid, &list);
2355         if(ret == FALSE)
2356         {
2357                 return -1;
2358         }
2359
2360         EINA_LIST_FOREACH((Eina_List *)list, l, data)
2361         {
2362                 if(data)
2363                 {
2364                         time_t nMarkedTime;
2365                         media_bookmark_get_marked_time(data, &nMarkedTime);
2366                         if(position == nMarkedTime)
2367                         {
2368                                 media_bookmark_get_bookmark_id(data, &bookmarkid);
2369                                 media_bookmark_get_thumbnail_path(data, &path);
2370                                 break;
2371                         }
2372                 }
2373         }
2374
2375         MpUtilMediaSvcBookmarkListClear(list);
2376
2377         if(media_bookmark_delete_from_db(bookmarkid) != MEDIA_CONTENT_ERROR_NONE)
2378         {
2379                 VideoLogInfo("[ERR] media_bookmark_delete_from_db()");
2380                 if(path)
2381                 {
2382                         free(path);
2383                         path = NULL;
2384                 }
2385                 return -1;
2386         }
2387
2388         if(path == NULL)
2389         {
2390                 VideoLogError("Thumbnail path is NULL");
2391                 return -1;
2392         }
2393
2394         ecore_file_init();
2395         if(ecore_file_exists(path))
2396         {
2397                 if(ecore_file_remove(path))
2398                 {
2399                         VideoLogInfo("Remove success :%s\n", path);
2400                 }
2401                 else
2402                 {
2403                         VideoLogInfo("Remove Failed :%s \n", path);
2404                 }
2405         }
2406         else
2407         {
2408                 VideoLogInfo("The file not eixst :%s\n", path);
2409         }
2410
2411         ecore_file_shutdown();
2412
2413         if(path)
2414         {
2415                 free(path);
2416                 path = NULL;
2417         }
2418
2419         return 0;
2420 }
2421
2422 int MpUtilMediaSvcBookmarkDeleteAll(char *vid)
2423 {
2424         VideoLogInfo("");
2425         bool ret = 0;
2426
2427         int bookmarkid = 0;
2428
2429         GList *list = NULL;
2430         media_bookmark_h data = NULL;
2431         Eina_List *l = NULL;
2432         char *szThumbnailPath = NULL;
2433
2434         ret = MpUtilMediaSvcBookmarkListGet(vid, &list);
2435         if(ret == FALSE)
2436         {
2437                 return -1;
2438         }
2439
2440         EINA_LIST_FOREACH((Eina_List *)list, l, data)
2441         {
2442                 if(data)
2443                 {
2444                         media_bookmark_get_bookmark_id(data, &bookmarkid);
2445                         media_bookmark_get_thumbnail_path(data, &szThumbnailPath);
2446
2447                         if(szThumbnailPath)
2448                         {
2449                                 ecore_file_init();
2450                                 if(ecore_file_exists(szThumbnailPath))
2451                                 {
2452                                         if(ecore_file_remove(szThumbnailPath))
2453                                         {
2454                                                 VideoLogInfo("Remove success : %s", szThumbnailPath);
2455                                         }
2456                                         else
2457                                         {
2458                                                 VideoLogInfo("Remove Failed : %s", szThumbnailPath);
2459                                         }
2460                                 }
2461                                 else
2462                                 {
2463                                         VideoLogInfo("The file not eixst :%s", szThumbnailPath);
2464                                 }
2465                                 ecore_file_shutdown();
2466                         }
2467
2468                         if(media_bookmark_delete_from_db(bookmarkid) != MEDIA_CONTENT_ERROR_NONE)
2469                         {
2470                                 VideoLogInfo("[ERR]minfo_delete_bookmark");
2471                                 return -1;
2472                         }
2473                 }
2474         }
2475
2476         MpUtilMediaSvcBookmarkListClear(list);
2477
2478         return 0;
2479 }
2480
2481 char* MpUtilMediaSvcBookmarkGetThumbnail(void* pBookmarkItemHandle)
2482 {
2483         char *szThumbnailPath = NULL;
2484
2485         media_bookmark_get_thumbnail_path((media_bookmark_h)pBookmarkItemHandle, &szThumbnailPath);
2486
2487         return szThumbnailPath;
2488 }
2489
2490 int MpUtilMediaSvcBookmarkGetPos(void* pBookmarkItemHandle)
2491 {
2492         time_t nBookmarkTime;
2493
2494         media_bookmark_get_marked_time((media_bookmark_h)pBookmarkItemHandle, &nBookmarkTime);
2495
2496         return (int)nBookmarkTime;
2497 }