viewer/smil-player/src/msg-smil-content-manager.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *    http://floralicense.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*==================================================================================================
  18  *                                                                      INCLUDE HEADERS
  19  *==================================================================================================*/
  20 #include <metadata_extractor.h>
  21 #include "msg-smil-content-manager.h"
  22 #include "msg-smil-player.h"
  23
  24 /*==================================================================================================
  25  *                                                              FUNCTION DECLARATIONS
  26  *==================================================================================================*/
  27 /**
  28 *@fn                    __msg_smil_content_mgr_create_page_content(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle, msg_struct_t *msgData);
  29 *@brief                 This function creates the Slide Page Queue which is further passed to the UI for display.
  30 *@return                        MSG_SUCCESS on success , else failure return code
  31 *@param[in]             msgData    This is the message data
  32 *@param[in]             smilContMgrHndle    The Content Manager Handler
  33 *@param[out] None.
  34 */
  35 static MSG_SMIL_ERROR_E __msg_smil_content_mgr_create_page_content(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle, msg_struct_t msg_info_t);
  36 static SMIL_SLIDE_INFO_S *__msg_smil_content_mgr_create_mixed_message(msg_struct_t msg_info_t);
  37 static SMIL_SLIDE_INFO_S *__msg_smil_content_mgr_create_related_message(msg_struct_t msg_info_t);
  38 static SMIL_MASTER_SLIDE_INFO_S *__msg_smil_content_mgr_create_master_slide(msg_struct_t msg_info_t);
  39 static void __msg_smil_content_mgr_free_slide_list(SMIL_SLIDE_INFO_S *deleteSlide);
  40 static MSG_BOOL __msg_smil_cont_mgr_is_valid_slide(SMIL_MASTER_SLIDE_INFO_S *commonData, int curSlideIdx);
  41
  42 /*==================================================================================================
  43  *                                                              FUNCTION IMPLEMENTATIONS
  44  *================================================================================================*/
  45 MSG_SMIL_ERROR_E _msg_smil_create_content_mgr(msg_struct_t msg_info_t, SMIL_CONTENT_MGR_HANDLE_S **smilContMgrHndle)
  46 {
  47         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
  48         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, msg_info_t == NULL, MSG_ERR_SMIL_NULL_MESSAGE);
  49         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, MSG_ERR_SMIL_INVALID_PARAMETER);
  50         MSG_SMIL_ERROR_E err = MSG_ERR_SMIL_UNKNOWN;
  51
  52         /*allocate memory for the content mgr handler*/
  53         *smilContMgrHndle = (SMIL_CONTENT_MGR_HANDLE_S *)calloc(1, sizeof(SMIL_CONTENT_MGR_HANDLE_S));
  54         if (*smilContMgrHndle == NULL) {
  55                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "calloc is failed");
  56                 return MSG_ERR_SMIL_INVALID_STORAGE;
  57         }
  58
  59         /*create and set page content info.*/
  60         err = __msg_smil_content_mgr_create_page_content(*smilContMgrHndle, msg_info_t);
  61         if (err != MSG_SMIL_SUCCESS) {
  62                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "__msg_smil_content_mgr_create_page_content is failed");
  63                 if (*smilContMgrHndle != NULL) {
  64                         free(*smilContMgrHndle);
  65                         *smilContMgrHndle = NULL;
  66                 }
  67
  68                 return err;
  69         }
  70
  71         //store mmsdata struct handler
  72         (*smilContMgrHndle)->msg_info_t = msg_info_t;
  73
  74         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
  75         return MSG_SMIL_SUCCESS;
  76 }
  77
  78 static SMIL_MASTER_SLIDE_INFO_S *__msg_smil_content_mgr_create_master_slide(msg_struct_t msg_info_t)
  79 {
  80         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
  81         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, msg_info_t == NULL, NULL);
  82         SMIL_MASTER_SLIDE_INFO_S *commonData = NULL;
  83
  84         /*allocate master slide*/
  85         commonData = (SMIL_MASTER_SLIDE_INFO_S *)calloc(1, sizeof(SMIL_MASTER_SLIDE_INFO_S));
  86         if (commonData == NULL) {
  87                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "calloc is failed");
  88                 return NULL;
  89         }
  90
  91         msg_list_handle_t pagelist_info = NULL;
  92         msg_get_list_handle(msg_info_t, MSG_MMS_PAGE_LIST_HND, (void **)&pagelist_info);
  93
  94         /*Get page count */
  95         commonData->pageCnt = msg_list_length(pagelist_info);
  96
  97         /*Get Attachment List*/
  98         msg_list_handle_t attachlist_info = NULL;
  99         msg_get_list_handle(msg_info_t, MSG_MMS_ATTACH_LIST_HND, (void **)&attachlist_info);
 100         commonData->attachCnt = msg_list_length(attachlist_info);
 101
 102         /*Get MetaData List*/
 103         msg_list_handle_t metalist_info = NULL;
 104         msg_get_list_handle(msg_info_t, MSG_MMS_META_LIST_HND, (void **)&metalist_info);
 105         commonData->metaCnt = msg_list_length(metalist_info);
 106
 107         /*Get Region List */
 108         msg_list_handle_t regionlist_info = NULL;
 109         msg_get_list_handle(msg_info_t, MSG_MMS_REGION_LIST_HND, (void **)&regionlist_info);
 110         commonData->regionCnt = msg_list_length(regionlist_info);
 111
 112         /*Get Transition List */
 113         msg_list_handle_t translist_info = NULL;
 114         msg_get_list_handle(msg_info_t, MSG_MMS_TRANSITION_LIST_HND, (void **)&translist_info);
 115         commonData->transitionCnt = msg_list_length(translist_info);
 116
 117         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 118
 119         return commonData;
 120 }
 121
 122
 123 static SMIL_SLIDE_INFO_S *__msg_smil_content_mgr_create_mixed_message(msg_struct_t msg_info_t)
 124 {
 125         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 126         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, msg_info_t == NULL, NULL);
 127         SMIL_SLIDE_INFO_S *newSlideContent = NULL;
 128         int pageCnt = 0;
 129         int attachCnt = 0;
 130         MSG_BOOL isMixedMsg = FALSE;
 131         msg_list_handle_t pagelist_info = NULL;
 132         msg_list_handle_t attachlist_info = NULL;
 133
 134         msg_get_list_handle(msg_info_t, MSG_MMS_PAGE_LIST_HND, (void **)&pagelist_info);
 135         pageCnt = msg_list_length(pagelist_info);
 136
 137         msg_get_list_handle(msg_info_t, MSG_MMS_ATTACH_LIST_HND, (void **)&attachlist_info);
 138         attachCnt = msg_list_length(attachlist_info);
 139
 140         isMixedMsg = (pageCnt == 0) ? TRUE : FALSE;
 141
 142         if (isMixedMsg) {
 143                 newSlideContent = (SMIL_SLIDE_INFO_S *)calloc(1, sizeof(SMIL_SLIDE_INFO_S));
 144                 if (newSlideContent == NULL) {
 145                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "calloc is failed");
 146                         return NULL;
 147                 }
 148
 149                 newSlideContent->pageIdx = pageCnt;
 150                 newSlideContent->slideStatus = PLAYER_STATUS_NONE;
 151                 newSlideContent->nextSlide = NULL;
 152                 newSlideContent->prevSlide = NULL;
 153
 154                 /* set pageinfo with no data*/
 155                 newSlideContent->pageInfo = (SMIL_PAGE_INFO_S *)calloc(1, sizeof(SMIL_PAGE_INFO_S));
 156                 if (newSlideContent->pageInfo == NULL) {
 157                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "calloc is failed");
 158                         free(newSlideContent);
 159                         newSlideContent = NULL;
 160                         return NULL;
 161                 }
 162
 163                 // Init
 164                 newSlideContent->pageInfo->mediaCnt = 0;
 165                 newSlideContent->pageInfo->isTexttop = FALSE;
 166                 newSlideContent->pageInfo->hasText = FALSE;
 167                 newSlideContent->pageInfo->hasImage = FALSE;
 168                 newSlideContent->pageInfo->hasVideo = FALSE;
 169                 newSlideContent->pageInfo->hasAudio = FALSE;
 170                 newSlideContent->pageInfo->pageDuration = MSG_MMS_SMIL_HELP_PAGE_DURATION;
 171                 _msg_smil_cont_mgr_set_cur_slide_help_page(newSlideContent, ((attachCnt > 0) ? TRUE : FALSE));
 172
 173                 /*create master slide*/
 174                 newSlideContent->commonData = __msg_smil_content_mgr_create_master_slide(msg_info_t);
 175                 if (newSlideContent->commonData == NULL) {
 176                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "__msg_smil_content_mgr_create_master_slide is failed");
 177                         if (newSlideContent) {
 178                                 free(newSlideContent);
 179                                 newSlideContent = NULL;
 180                         }
 181                         return NULL;
 182                 }
 183         }  else {
 184                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "This is not mixed message");
 185         }
 186
 187         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 188         return newSlideContent;
 189 }
 190
 191 static SMIL_SLIDE_INFO_S *__msg_smil_content_mgr_create_related_message(msg_struct_t msg_info_t)
 192 {
 193         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 194         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, msg_info_t == NULL, NULL);
 195         SMIL_SLIDE_INFO_S *firstSlide = NULL;   /*first slide pointer to be returned*/
 196         SMIL_SLIDE_INFO_S *newSlideContent = NULL;
 197         int pageCnt = 0;
 198         int attachCnt = 0;
 199         MSG_BOOL bSkipEmptyPage = FALSE;
 200         msg_list_handle_t pagelist_info = NULL;
 201         msg_struct_t page_info = NULL;
 202         msg_list_handle_t medialist_info = NULL;
 203         msg_list_handle_t attachlist_info = NULL;
 204
 205         //Get page info and count
 206         msg_get_list_handle(msg_info_t, MSG_MMS_PAGE_LIST_HND, (void **)&pagelist_info);
 207         pageCnt = msg_list_length(pagelist_info);
 208
 209         //Get attach info and count
 210         msg_get_list_handle(msg_info_t, MSG_MMS_ATTACH_LIST_HND, (void **)&attachlist_info);
 211         attachCnt = msg_list_length(attachlist_info);
 212
 213         if (pageCnt > 0) {
 214                 SMIL_SLIDE_INFO_S *prev = NULL;
 215                 int pageIndex = 0;
 216                 int mediaCnt = 0;
 217
 218                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "msgData->pageCnt = %d", pageCnt);
 219
 220                 while (pageIndex < pageCnt) {
 221                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "pgCount = %d", pageIndex);
 222
 223                         page_info = _msg_smil_cont_mgr_get_nth_page_struct_handle(pagelist_info, pageIndex);
 224                         medialist_info = _msg_smil_cont_mgr_get_page_media_list_handle(page_info);
 225                         mediaCnt = msg_list_length(medialist_info);
 226                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "mediaCnt = %d", mediaCnt);
 227
 228                         /* For empty page, if there's only 1 page and help page is exist, then skip composing 1st empty page. */
 229                         if (pageCnt == 1 && pageIndex == 0 && mediaCnt == 0 && attachCnt > 0) {
 230                                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "There's 1 empty page, but attachment is exist, skip composing empty 1 page!");
 231                                 bSkipEmptyPage = TRUE;
 232                                 break;
 233                         }
 234
 235                         newSlideContent = (SMIL_SLIDE_INFO_S *)calloc(1, sizeof(SMIL_SLIDE_INFO_S));
 236                         if (newSlideContent == NULL) {
 237                                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "calloc is failed");
 238                                 if (firstSlide == NULL) {
 239                                         return NULL;
 240                                 } else
 241                                         goto FREE_SLIDE_LIST;
 242                         }
 243
 244                         /*init silde info data*/
 245                         newSlideContent->pageIdx = pageIndex;
 246                         newSlideContent->slideStatus = PLAYER_STATUS_NONE;
 247                         newSlideContent->nextSlide = NULL;
 248                         newSlideContent->prevSlide = NULL;
 249
 250                         /*set master(commonData) slide*/
 251                         if (pageIndex == 0) {
 252                                 /*set smilContent of content mgr as first slide pointer */
 253                                 firstSlide = newSlideContent;
 254
 255                                 newSlideContent->commonData = __msg_smil_content_mgr_create_master_slide(msg_info_t);
 256                                 if (newSlideContent->commonData == NULL) {
 257                                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "__msg_smil_content_mgr_create_master_slide is failed");
 258                                         goto FREE_SLIDE_LIST;
 259                                 }
 260                         } else {
 261                                 /* Keeping one copy of commonData and makig all pointers to point to that copy */
 262                                 newSlideContent->commonData = firstSlide->commonData;
 263                         }
 264
 265                         /*set pageinfo */
 266                         newSlideContent->pageInfo = (SMIL_PAGE_INFO_S *)calloc(1, sizeof(SMIL_PAGE_INFO_S));
 267                         if (newSlideContent->pageInfo == NULL) {
 268                                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "calloc is failed");
 269                                 goto FREE_SLIDE_LIST;
 270                         }
 271
 272                         // Init
 273                         newSlideContent->pageInfo->mediaCnt = mediaCnt;
 274                         newSlideContent->pageInfo->isTexttop = FALSE;
 275                         newSlideContent->pageInfo->hasText = FALSE;
 276                         newSlideContent->pageInfo->hasImage = FALSE;
 277                         newSlideContent->pageInfo->hasVideo = FALSE;
 278                         newSlideContent->pageInfo->hasAudio = FALSE;
 279
 280                         msg_get_int_value(page_info, MSG_MMS_PAGE_PAGE_DURATION_INT, &(newSlideContent->pageInfo->pageDuration));
 281
 282                         int index = 0;
 283                         while (index < mediaCnt) {
 284                                 msg_struct_t media_info = _msg_smil_cont_mgr_get_page_nth_media_struct_handle(medialist_info, index);
 285                                 int mediaType = 0;
 286                                 _msg_smil_cont_mgr_get_media_int_value(media_info, MSG_MMS_MEDIA_TYPE_INT, &mediaType);
 287
 288                                 if (mediaType == MMS_SMIL_MEDIA_TEXT) {
 289                                         newSlideContent->pageInfo->hasText = TRUE;
 290                                         index++;
 291                                         continue;
 292                                 } else if (mediaType == MMS_SMIL_MEDIA_AUDIO) {
 293                                         newSlideContent->pageInfo->hasAudio = TRUE;
 294                                         index++;
 295                                         continue;
 296                                 } else if (mediaType == MMS_SMIL_MEDIA_VIDEO || mediaType == MMS_SMIL_MEDIA_IMG_OR_VIDEO) {
 297                                         newSlideContent->pageInfo->hasVideo = TRUE;
 298                                         index++;
 299                                         continue;
 300                                 } else if (mediaType == MMS_SMIL_MEDIA_IMG || mediaType == MMS_SMIL_MEDIA_ANIMATE) {
 301                                         newSlideContent->pageInfo->hasImage = TRUE;
 302                                         index++;
 303                                         continue;
 304                                 } else {
 305                                         index++;
 306                                 }
 307                         }
 308
 309                         //check isTexttop
 310                         if (newSlideContent->pageInfo->hasText &&
 311                                 (newSlideContent->pageInfo->hasVideo || newSlideContent->pageInfo->hasImage)) {
 312                                 int nTop_0 = 0;
 313                                 int nTop_1 = 0;
 314                                 int nHeight_0 = 0;
 315                                 int nHeight_1 = 0;
 316                                 char szID_0[MAX_SMIL_REGION_ID] = {0,};
 317                                 char szID_1[MAX_SMIL_REGION_ID] = {0,};
 318
 319                                 msg_list_handle_t region_list = NULL;
 320                                 msg_get_list_handle(msg_info_t, MSG_MMS_REGION_LIST_HND, (void **)&region_list);
 321
 322                                 /* Get 0th region */
 323                                 msg_struct_t region_info_0 = (msg_struct_t)msg_list_nth_data(region_list, 0);
 324                                 msg_get_str_value(region_info_0, MSG_MMS_REGION_ID_STR, szID_0, sizeof(szID_0));
 325                                 msg_get_int_value(region_info_0, MSG_MMS_REGION_LENGTH_TOP_INT, &nTop_0);
 326                                 msg_get_int_value(region_info_0, MSG_MMS_REGION_LENGTH_HEIGHT_INT, &nHeight_0);
 327
 328                                 /* Get 1th region */
 329                                 msg_struct_t region_info_1 = (msg_struct_t)msg_list_nth_data(region_list, 1);
 330                                 msg_get_str_value(region_info_1, MSG_MMS_REGION_ID_STR, szID_1, sizeof(szID_1));
 331                                 msg_get_int_value(region_info_1, MSG_MMS_REGION_LENGTH_TOP_INT, &nTop_1);
 332                                 msg_get_int_value(region_info_1, MSG_MMS_REGION_LENGTH_HEIGHT_INT, &nHeight_1);
 333
 334                                 /*check text top
 335                                  *      if (text's top == 0 & image's top != 0)
 336                                  *              text top
 337                                  *      else if (text's top < image's top)
 338                                  *              text top
 339                                  *      else if (text's top == 0 & image's top == 0) {
 340                                  *              if (text' height < image's height )
 341                                  *                      text top
 342                                  *      }
 343                                  */
 344
 345                                 /*find and set image, text region*/
 346                                 if (!strcasecmp(szID_0, "Image")) {     /*Image top region_info_0 is IMAGE REGION*/
 347                                         if (nTop_1 == 0 && nTop_0 != 0) {
 348                                                 newSlideContent->pageInfo->isTexttop = TRUE;
 349                                         } else if (nTop_1 < nTop_0) {
 350                                                 newSlideContent->pageInfo->isTexttop = TRUE;
 351                                         } else if (nTop_1 == 0 && nTop_0 == 0) {
 352                                                 if (nHeight_1 < nHeight_0) {
 353                                                         newSlideContent->pageInfo->isTexttop = TRUE;
 354                                                 }
 355                                         }
 356
 357                                 } else if (!strcasecmp(szID_1, "Image")) { /* region_info_1 is IMAGE_REGION */
 358                                         if (nTop_0 == 0 && nTop_1 != 0) {
 359                                                 newSlideContent->pageInfo->isTexttop = TRUE;
 360                                         } else if (nTop_0 < nTop_1) {
 361                                                 newSlideContent->pageInfo->isTexttop = TRUE;
 362                                         } else if (nTop_0 == 0 && nTop_1 == 0) {
 363                                                 if (nHeight_0 < nHeight_1) {
 364                                                         newSlideContent->pageInfo->isTexttop = TRUE;
 365                                                 }
 366                                         }
 367                                 }
 368                         }
 369
 370                         /*set prev, next slide pointer*/
 371                         newSlideContent->prevSlide = prev;
 372                         if (prev != NULL) {
 373                                 prev->nextSlide = newSlideContent;
 374                         }
 375
 376                         prev = newSlideContent;
 377                         pageIndex++;
 378                 }
 379         } else {
 380                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "This is not related message");
 381         }
 382
 383         if (attachCnt > 0) {
 384                 SMIL_SLIDE_INFO_S *lastSlide = NULL;    /*last slide pointer to ref for help page */
 385                 newSlideContent = (SMIL_SLIDE_INFO_S *)calloc(1, sizeof(SMIL_SLIDE_INFO_S));
 386                 if (newSlideContent == NULL) {
 387                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "calloc is failed");
 388                                 return NULL;
 389                 }
 390
 391                 newSlideContent->pageIdx = (bSkipEmptyPage) ? pageCnt-1 : pageCnt;              //set last page
 392                 newSlideContent->slideStatus = PLAYER_STATUS_NONE;
 393                 newSlideContent->nextSlide = NULL;
 394
 395                 if (firstSlide)
 396                         newSlideContent->commonData = firstSlide->commonData;
 397                 else
 398                         newSlideContent->commonData = __msg_smil_content_mgr_create_master_slide(msg_info_t);
 399
 400                 /*set pageinfo */
 401                 newSlideContent->pageInfo = (SMIL_PAGE_INFO_S *)calloc(1, sizeof(SMIL_PAGE_INFO_S));
 402                 if (newSlideContent->pageInfo == NULL) {
 403                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "calloc is failed");
 404                         if (firstSlide == NULL) {
 405                                 return NULL;
 406                         } else
 407                         goto FREE_SLIDE_LIST;
 408                 }
 409
 410                 // Init
 411                 newSlideContent->pageInfo->mediaCnt = 0;
 412                 newSlideContent->pageInfo->isTexttop = FALSE;
 413                 newSlideContent->pageInfo->hasText = FALSE;
 414                 newSlideContent->pageInfo->hasImage = FALSE;
 415                 newSlideContent->pageInfo->hasVideo = FALSE;
 416                 newSlideContent->pageInfo->hasAudio = FALSE;
 417                 newSlideContent->pageInfo->pageDuration = MSG_MMS_SMIL_HELP_PAGE_DURATION;
 418                 _msg_smil_cont_mgr_set_cur_slide_help_page(newSlideContent, TRUE);
 419
 420                 /* set no media contents */
 421
 422                 if (firstSlide) {
 423                         lastSlide = firstSlide;         //set first slide for searching last slide
 424
 425                         for (; lastSlide->nextSlide != NULL ;)
 426                                 lastSlide = lastSlide->nextSlide;
 427
 428                         newSlideContent->prevSlide = lastSlide;
 429                         lastSlide->nextSlide = newSlideContent;
 430
 431                         firstSlide->commonData->pageCnt += 1;
 432                 } else {
 433                         newSlideContent->prevSlide = NULL;
 434                         newSlideContent->nextSlide = NULL;
 435
 436                         firstSlide = newSlideContent;
 437                 }
 438         }
 439
 440
 441         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 442         return firstSlide;
 443
 444 FREE_SLIDE_LIST:
 445         /*free current slide data*/
 446         if (newSlideContent) {
 447                 if (newSlideContent->pageInfo) {
 448                         free(newSlideContent->pageInfo);
 449                         newSlideContent->pageInfo = NULL;
 450                 }
 451                 free(newSlideContent);
 452                 newSlideContent = NULL;
 453         }
 454
 455         __msg_smil_content_mgr_free_slide_list(firstSlide);
 456
 457         return NULL;
 458 }
 459
 460
 461
 462 /*********************************************************************************************
 463 *This method allocates memory and does a deep copy of the message details received from the FW.
 464 *********************************************************************************************/
 465 static MSG_SMIL_ERROR_E __msg_smil_content_mgr_create_page_content(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle, msg_struct_t msg_info_t)
 466 {
 467         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 468         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, MSG_ERR_SMIL_INVALID_PARAMETER);
 469         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, msg_info_t == NULL, MSG_ERR_SMIL_INVALID_PARAMETER);
 470
 471         MSG_BOOL isMixedMsg = FALSE;
 472         int pageCnt = 0;
 473         msg_list_handle_t pagelist_info = NULL;
 474         msg_get_list_handle(msg_info_t, MSG_MMS_PAGE_LIST_HND, (void **)&pagelist_info);
 475         pageCnt = msg_list_length(pagelist_info);
 476
 477         isMixedMsg = (pageCnt == 0) ? TRUE : FALSE;
 478
 479         if (isMixedMsg) {       /*multipart mixed mms*/
 480                 smilContMgrHndle->smilContent = __msg_smil_content_mgr_create_mixed_message(msg_info_t);
 481                 if (smilContMgrHndle->smilContent == NULL) {
 482                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "__msg_smil_content_mgr_create_mixed_message is failed");
 483                         return MSG_ERR_SMIL_INVALID_STORAGE;
 484                 }
 485         } else {        /*multipart related mms*/
 486                 smilContMgrHndle->smilContent = __msg_smil_content_mgr_create_related_message(msg_info_t);
 487                 if (smilContMgrHndle->smilContent == NULL) {
 488                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "__msg_smil_content_mgr_create_mixed_message is failed");
 489                         return MSG_ERR_SMIL_INVALID_STORAGE;
 490                 }
 491         }
 492         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 493
 494         return MSG_SMIL_SUCCESS;
 495 }
 496
 497
 498
 499 static void __msg_smil_content_mgr_free_slide_list(SMIL_SLIDE_INFO_S *deleteSlide)
 500 {
 501         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 502         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, deleteSlide == NULL);
 503
 504         if (deleteSlide->nextSlide == NULL) {   /*Single Slide message*/
 505                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Freeing smilContent if MMS has one page");
 506                 /*free commonData*/
 507                 if (deleteSlide->commonData != NULL) {
 508                         free(deleteSlide->commonData);
 509                         deleteSlide->commonData = NULL;
 510                 }
 511                 /*free page data*/
 512                 if (deleteSlide->pageInfo != NULL) {
 513                         free(deleteSlide->pageInfo);
 514                         deleteSlide->pageInfo = NULL;
 515                 }
 516                 free(deleteSlide);
 517
 518                 return;
 519         } else {        /*Multiple Slides message*/
 520                 SMIL_SLIDE_INFO_S *nextSlide = NULL;
 521                 while (deleteSlide->nextSlide != NULL) {
 522                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Freeing smilContent: page = %d ", deleteSlide->pageIdx);
 523                         nextSlide = deleteSlide->nextSlide;
 524                         /*free commonData*/
 525                         if (deleteSlide->pageIdx == 0) {
 526                                 if (deleteSlide->commonData != NULL) {
 527                                         free(deleteSlide->commonData);
 528                                         deleteSlide->commonData = NULL;
 529                                 }
 530                         }
 531
 532                         free(deleteSlide);
 533
 534                         deleteSlide = nextSlide;
 535                 }
 536
 537                 /*free the last slide data*/
 538                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Freeing smilContent last page");
 539                 /*free page data*/
 540                 if (deleteSlide->pageInfo != NULL) {
 541                         free(deleteSlide->pageInfo);
 542                         deleteSlide->pageInfo = NULL;
 543                 }
 544                 free(deleteSlide);
 545
 546         }
 547
 548         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 549 }
 550
 551
 552 void _msg_smil_destroy_content_mgr(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle)
 553 {
 554         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 555         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL);
 556         SMIL_SLIDE_INFO_S *deleteSlide = smilContMgrHndle->smilContent;
 557
 558         __msg_smil_content_mgr_free_slide_list(deleteSlide);
 559         smilContMgrHndle->smilContent = NULL;
 560
 561         free(smilContMgrHndle);
 562
 563         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 564 }
 565
 566
 567 static MSG_BOOL __msg_smil_cont_mgr_is_valid_slide(SMIL_MASTER_SLIDE_INFO_S *commonData, int curSlideIdx)
 568 {
 569         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, commonData == NULL, FALSE);
 570
 571         if (commonData->pageCnt > 0) {  /*Multipart Related message*/
 572                 if (curSlideIdx > (commonData->pageCnt - 1) || curSlideIdx < 0)
 573                         return  FALSE;
 574         } else if (commonData->pageCnt == 0) {  /*Multipart Mixed message*/
 575                 if (curSlideIdx > (commonData->pageCnt) || curSlideIdx < 0)
 576                         return  FALSE;
 577         } else {
 578                 return FALSE;
 579         }
 580
 581         return TRUE;
 582 }
 583
 584
 585 MSG_BOOL _msg_smil_cont_mgr_set_status(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle, int slideIdx, SMIL_PLAYER_STATUS_E event)
 586 {
 587         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 588         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, FALSE);
 589         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent == NULL, FALSE);
 590         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent->commonData == NULL, FALSE);
 591         SMIL_SLIDE_INFO_S *findSlide = smilContMgrHndle->smilContent;
 592         int count = 0;
 593
 594         if (__msg_smil_cont_mgr_is_valid_slide(findSlide->commonData, slideIdx) == FALSE) {
 595                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "Slide index is invalid");
 596                 return FALSE;
 597         }
 598
 599         while (count < slideIdx) {
 600                 findSlide = findSlide->nextSlide;
 601                 count++;
 602         }
 603         findSlide->slideStatus = event;
 604
 605         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Slide number = %d", findSlide->pageIdx);
 606         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Slide Status = %d", findSlide->slideStatus);
 607
 608         return TRUE;
 609 }
 610
 611 SMIL_PLAYER_STATUS_E _msg_smil_cont_mgr_get_status(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle, int slideIdx)
 612 {
 613         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 614         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, PLAYER_STATUS_INVALID);
 615         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent == NULL, PLAYER_STATUS_INVALID);
 616         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent->commonData == NULL, PLAYER_STATUS_INVALID);
 617         SMIL_SLIDE_INFO_S *findSlide = smilContMgrHndle->smilContent;
 618         int count = 0;
 619
 620         if (__msg_smil_cont_mgr_is_valid_slide(findSlide->commonData, slideIdx) == FALSE) {
 621                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "Slide index is invalid");
 622                 return PLAYER_STATUS_INVALID;
 623         }
 624
 625         while (count < slideIdx) {
 626                 findSlide = findSlide->nextSlide;
 627                 count++;
 628         }
 629
 630         return findSlide->slideStatus;
 631 }
 632
 633
 634
 635 SMIL_PLAYER_STATUS_E _msg_smil_cont_mgr_get_cur_slide_status(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle)
 636 {
 637         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 638         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, PLAYER_STATUS_INVALID);
 639         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent == NULL, PLAYER_STATUS_INVALID);
 640         SMIL_SLIDE_INFO_S *findSlide = smilContMgrHndle->smilContent;
 641         int count = 0;
 642
 643         while (count < smilContMgrHndle->curSlideIdx) {
 644                 findSlide = findSlide->nextSlide;
 645                 count++;
 646
 647                 if (findSlide == NULL) {
 648                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "smilContMgrHndle->smilContent is NULL");
 649                         return PLAYER_STATUS_INVALID;
 650                 }
 651         }
 652
 653         return (findSlide->slideStatus);
 654 }
 655
 656
 657 int _msg_smil_cont_mgr_get_cur_slide_idx(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle)
 658 {
 659         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 660         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, MSG_MMS_SLIDE_INVALID);
 661
 662         return smilContMgrHndle->curSlideIdx;
 663 }
 664
 665
 666 MSG_BOOL _msg_smil_cont_mgr_set_cur_slide_idx(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle, int slideIdx)
 667 {
 668         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 669         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, FALSE);
 670         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent == NULL, FALSE);
 671         SMIL_SLIDE_INFO_S *firstSlide = smilContMgrHndle->smilContent;
 672
 673         if (firstSlide->commonData) {
 674                 if (__msg_smil_cont_mgr_is_valid_slide(firstSlide->commonData, slideIdx) == FALSE) {
 675                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "Slide index is invalid");
 676                         return FALSE;
 677                 }
 678
 679                 smilContMgrHndle->curSlideIdx = slideIdx;
 680         } else {
 681                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "Slide index is invalid");
 682                 return FALSE;
 683         }
 684
 685         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 686         return TRUE;
 687 }
 688
 689
 690 int _msg_smil_cont_mgr_get_total_slide_count(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle)
 691 {
 692         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 693         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, MSG_MMS_SLIDE_INVALID);
 694         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent == NULL, MSG_MMS_SLIDE_INVALID);
 695         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent->commonData == NULL, MSG_MMS_SLIDE_INVALID);
 696
 697         return smilContMgrHndle->smilContent->commonData->pageCnt;
 698 }
 699
 700
 701 SMIL_SLIDE_INFO_S *_msg_smil_cont_mgr_get_cur_slide(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle)
 702 {
 703         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 704         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, NULL);
 705         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent == NULL, NULL);
 706         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent->commonData == NULL, NULL);
 707         SMIL_SLIDE_INFO_S *findSlide = smilContMgrHndle->smilContent;
 708         int pageCnt = findSlide->commonData->pageCnt;
 709         int count = 0;
 710
 711         while (count < pageCnt) {
 712                 if (count == smilContMgrHndle->curSlideIdx) {
 713                         return findSlide;
 714                 }
 715                 findSlide = findSlide->nextSlide;
 716                 count++;
 717         }
 718
 719         //Adjust Mixed type msg, first slide should be set as cur slide
 720         if (pageCnt == 0) {
 721                 msg_list_handle_t page_list_t = _msg_smil_cont_mgr_get_page_list_handle(smilContMgrHndle);
 722                 if (!page_list_t) {
 723                         return findSlide;
 724                 }
 725         }
 726         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 727
 728         return NULL;
 729 }
 730
 731
 732 SMIL_SLIDE_INFO_S *_msg_smil_cont_mgr_get_slide(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle, int slideIdx)
 733 {
 734         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 735         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, NULL);
 736         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent == NULL, NULL);
 737         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "slide Index = %d", slideIdx);
 738         SMIL_SLIDE_INFO_S *findSlide = smilContMgrHndle->smilContent;
 739
 740         if (findSlide->commonData) {
 741                 if (__msg_smil_cont_mgr_is_valid_slide(findSlide->commonData, slideIdx) == FALSE) {
 742                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "Slide index is invalid");
 743                         return NULL;
 744                 }
 745
 746                 while (findSlide->pageIdx < slideIdx)   {
 747                         findSlide = findSlide->nextSlide;
 748                         if (findSlide == NULL)
 749                                 break;
 750                 }
 751         }
 752
 753         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 754         return findSlide;
 755 }
 756
 757 void _msg_smil_cont_mgr_set_cur_slide_help_page(SMIL_SLIDE_INFO_S *singleSlideInfo, MSG_BOOL bSet)
 758 {
 759         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 760         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, singleSlideInfo == NULL);
 761         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, singleSlideInfo->pageInfo == NULL);
 762
 763         singleSlideInfo->pageInfo->isHelpPage = bSet;
 764
 765         if (bSet) {
 766                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Current page set as help page!");
 767         } else  {
 768                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Current page set as normal page!");
 769         }
 770
 771         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 772 }
 773
 774 MSG_BOOL _msg_smil_cont_mgr_is_cur_slide_help_page(SMIL_SLIDE_INFO_S *singleSlideInfo)
 775 {
 776         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 777         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, singleSlideInfo == NULL, FALSE);
 778         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, singleSlideInfo->pageInfo == NULL, FALSE);
 779
 780         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "The result of checking help page = %d", singleSlideInfo->pageInfo->isHelpPage);
 781
 782         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 783         return singleSlideInfo->pageInfo->isHelpPage;
 784 }
 785
 786 MSG_BOOL _msg_smil_cont_mgr_delete_help_page(msg_struct_t msg_info_t, SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle)
 787 {
 788         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 789         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, msg_info_t == NULL, FALSE);
 790         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, FALSE);
 791         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent == NULL, FALSE);
 792
 793         MSG_BOOL isMixedMsg = FALSE;
 794         msg_list_handle_t pagelist_info = NULL;
 795         msg_struct_t    page_info = NULL;
 796         msg_list_handle_t medialist_info = NULL;
 797         msg_list_handle_t attachlist_info = NULL;
 798         int pageCnt = 0;
 799         int mediaCnt = 0;
 800         int attachCnt = 0;
 801
 802         SMIL_SLIDE_INFO_S *curSlide = smilContMgrHndle->smilContent;
 803
 804         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, curSlide == NULL, FALSE);
 805         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, curSlide->commonData == NULL, FALSE);
 806         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, curSlide->pageInfo == NULL, FALSE);
 807
 808         /* get page list info */
 809         msg_get_list_handle(msg_info_t, MSG_MMS_PAGE_LIST_HND, (void **)&pagelist_info);
 810         pageCnt = msg_list_length(pagelist_info);
 811
 812         isMixedMsg = (pageCnt == 0) ? TRUE : FALSE;
 813
 814         if (isMixedMsg) {
 815                 /* change current slide page tag */
 816                 _msg_smil_cont_mgr_set_cur_slide_help_page(curSlide, FALSE);
 817
 818                 /*set prev, next slide pointer*/
 819                 curSlide->prevSlide = NULL;
 820                 curSlide->nextSlide = NULL;
 821         } else {                // related msg
 822
 823                 msg_get_list_handle(msg_info_t, MSG_MMS_ATTACH_LIST_HND, (void **)&attachlist_info);
 824                 attachCnt = msg_list_length(attachlist_info);
 825
 826                 //Check 1st page media info, media count
 827                 page_info = _msg_smil_cont_mgr_get_nth_page_struct_handle(pagelist_info, 0);
 828                 medialist_info = _msg_smil_cont_mgr_get_page_media_list_handle(page_info);
 829                 mediaCnt = msg_list_length(medialist_info);
 830
 831                 if (attachCnt > 0) {
 832                         if (pageCnt == 1 && mediaCnt == 0) {    // condition for skip and show Help page direct
 833                                 /* change current slide page tag */
 834                                 _msg_smil_cont_mgr_set_cur_slide_help_page(curSlide, FALSE);
 835
 836                                 /*set prev, next slide pointer*/
 837                                 curSlide->prevSlide = NULL;
 838                                 curSlide->nextSlide = NULL;
 839                         } else {
 840                                 SMIL_SLIDE_INFO_S *firstSlide = NULL;   /*first slide */
 841                                 SMIL_SLIDE_INFO_S *lastSlide = NULL;    /*last slide pointer to ref for help page */
 842                                 SMIL_SLIDE_INFO_S *lastaheadSlide = NULL;       /*last ahead slide pointer */
 843
 844                                 firstSlide = _msg_smil_cont_mgr_get_slide(smilContMgrHndle, 0);
 845                                 if (firstSlide == NULL) {
 846                                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "failed in getting firstSlide");
 847                                         return FALSE;
 848                                 }
 849                                 lastSlide = firstSlide;         //copy pointer to last slide
 850
 851                                 for(; lastSlide->nextSlide; )
 852                                         lastSlide = lastSlide->nextSlide;
 853
 854                                 lastaheadSlide = lastSlide->prevSlide;
 855
 856                                 firstSlide->commonData->pageCnt -= 1;
 857                                 lastaheadSlide->nextSlide = NULL;
 858
 859                                 if (lastSlide->pageInfo) {
 860                                         free(lastSlide->pageInfo);
 861                                         lastSlide->pageInfo = NULL;
 862                                 }
 863
 864                                 free(lastSlide);
 865                                 lastSlide = NULL;
 866                         }
 867                 }
 868         }
 869
 870         MSG_UI_LEAVE(MSG_UI_LEVEL_DEBUG);
 871         return TRUE;
 872 }
 873
 874 /*
 875  *      functions for page/media struct handle with FW managed api
 876  */
 877 msg_list_handle_t _msg_smil_cont_mgr_get_page_list_handle(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle)
 878 {
 879         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 880         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, NULL);
 881         msg_struct_t msg_info_t = _msg_smil_cont_mgr_get_mms_body_struct_handle(smilContMgrHndle);
 882         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, msg_info_t == NULL, NULL);
 883
 884         int pageCnt = 0;
 885
 886         /*Get struct handle of current page */
 887         msg_list_handle_t pagelist_info = NULL;
 888         msg_get_list_handle(msg_info_t, MSG_MMS_PAGE_LIST_HND, (void **)&pagelist_info);
 889
 890         pageCnt = msg_list_length(pagelist_info);
 891
 892         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, pageCnt == 0, NULL);
 893
 894         return pagelist_info;
 895 }
 896
 897 msg_struct_t _msg_smil_cont_mgr_get_nth_page_struct_handle(msg_list_handle_t pagelist_info_t, int pageIdx)
 898 {
 899         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 900         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, pagelist_info_t == NULL, NULL);
 901
 902         int pageCnt = msg_list_length(pagelist_info_t);
 903         MSG_UI_RETVM_IF(MSG_UI_LEVEL_ERR, pageCnt == 0, NULL, "page length is 0, no page is exist");
 904
 905         /*Get page*/
 906         msg_struct_t page_info = NULL;
 907         page_info = (msg_struct_t)msg_list_nth_data(pagelist_info_t, pageIdx);
 908
 909         return page_info;
 910 }
 911
 912 int _msg_smil_cont_mgr_get_page_time_value(msg_struct_t pageInfo_t, int field)
 913 {
 914         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 915         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, pageInfo_t == NULL, MSG_MMS_SLIDE_INVALID);
 916         int time = 0;
 917
 918         /*Get page nDur */
 919         if (field == MSG_MMS_PAGE_PAGE_DURATION_INT) {
 920                 msg_get_int_value(pageInfo_t, MSG_MMS_PAGE_PAGE_DURATION_INT, &time);
 921                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "page duration time = %d", time);
 922         } else if (field == MSG_MMS_PAGE_BEGIN_TIME_INT) {
 923                 msg_get_int_value(pageInfo_t, MSG_MMS_PAGE_BEGIN_TIME_INT, &time);
 924                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "page begin time = %d", time);
 925         } else if (field == MSG_MMS_PAGE_END_TIME_INT) {
 926                 msg_get_int_value(pageInfo_t, MSG_MMS_PAGE_END_TIME_INT, &time);
 927                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "page end time = %d", time);
 928         } else if (field == MSG_MMS_PAGE_MIN_INT) {
 929                 msg_get_int_value(pageInfo_t, MSG_MMS_PAGE_MIN_INT, &time);
 930                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "page min time = %d", time);
 931         } else if (field == MSG_MMS_PAGE_MAX_INT) {
 932                 msg_get_int_value(pageInfo_t, MSG_MMS_PAGE_MAX_INT, &time);
 933                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "page max time = %d", time);
 934         } else if (field == MSG_MMS_PAGE_REPEAT_INT) {
 935                 msg_get_int_value(pageInfo_t, MSG_MMS_PAGE_REPEAT_INT, &time);
 936                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "page repeat time = %d", time);
 937         }
 938
 939         return time;
 940 }
 941
 942 msg_list_handle_t _msg_smil_cont_mgr_get_page_media_list_handle(msg_struct_t pageInfo_t)
 943 {
 944         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 945         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, pageInfo_t == NULL, NULL);
 946
 947         int mediaCnt = 0;
 948         /*Get media list handler */
 949         msg_list_handle_t medialist_info = NULL;
 950         msg_get_list_handle(pageInfo_t, MSG_MMS_PAGE_MEDIA_LIST_HND, (void **)&medialist_info);
 951         mediaCnt = msg_list_length(medialist_info);
 952
 953         if (mediaCnt == 0) {
 954                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "media count is 0, no medias in page");
 955                 return NULL;
 956         }
 957
 958         return medialist_info;
 959 }
 960
 961 msg_struct_t _msg_smil_cont_mgr_get_page_nth_media_struct_handle(msg_list_handle_t medialist_info_t, int mediaIdx)
 962 {
 963         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 964         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, medialist_info_t == NULL, NULL);
 965
 966         int mediaCnt = msg_list_length(medialist_info_t);
 967         MSG_UI_RETVM_IF(MSG_UI_LEVEL_ERR, mediaCnt == 0, NULL, "media count is 0, no medias in page");
 968
 969         /*Get media*/
 970         msg_struct_t media_info = NULL;
 971         media_info = (msg_struct_t)msg_list_nth_data(medialist_info_t, mediaIdx);
 972
 973         return media_info;
 974 }
 975
 976 void _msg_smil_cont_mgr_get_media_str_value(msg_struct_t media_info_t, int strfield, char *rtnStr)
 977 {
 978         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
 979         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, media_info_t == NULL);
 980
 981         if (strfield == MSG_MMS_MEDIA_TYPE_INT ||
 982                 strfield == MSG_MMS_MEDIA_DRM_TYPE_INT ||
 983                 strfield == MSG_MMS_MEDIA_SMIL_TEXT_HND ||
 984                 strfield == MSG_MMS_MEDIA_SMIL_AVI_HND ) {
 985                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "field value(%d) is not STRING type", strfield);
 986                 return;
 987         }
 988
 989         char strbuf[2048] = {0,};
 990
 991         if (strfield == MSG_MMS_MEDIA_SRC_STR)
 992                 msg_get_str_value(media_info_t, MSG_MMS_MEDIA_SRC_STR, strbuf, sizeof(strbuf));
 993         else if (strfield == MSG_MMS_MEDIA_FILENAME_STR)
 994                 msg_get_str_value(media_info_t, MSG_MMS_MEDIA_FILENAME_STR, strbuf, sizeof(strbuf));
 995         else if (strfield == MSG_MMS_MEDIA_FILEPATH_STR)
 996                 msg_get_str_value(media_info_t, MSG_MMS_MEDIA_FILEPATH_STR, strbuf, sizeof(strbuf));
 997         else if (strfield == MSG_MMS_MEDIA_CONTENT_ID_STR)
 998                 msg_get_str_value(media_info_t, MSG_MMS_MEDIA_CONTENT_ID_STR, strbuf, sizeof(strbuf));
 999         else if (strfield == MSG_MMS_MEDIA_REGION_ID_STR)
1000                 msg_get_str_value(media_info_t, MSG_MMS_MEDIA_REGION_ID_STR, strbuf, sizeof(strbuf));
1001         else if (strfield == MSG_MMS_MEDIA_ALTERNATIVE_STR)
1002                 msg_get_str_value(media_info_t, MSG_MMS_MEDIA_ALTERNATIVE_STR, strbuf, sizeof(strbuf));
1003         else if (strfield == MSG_MMS_MEDIA_DRM_FULLPATH_STR)
1004                 msg_get_str_value(media_info_t, MSG_MMS_MEDIA_DRM_FULLPATH_STR, strbuf, sizeof(strbuf));
1005
1006         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "STRING field value(%d) is %s", strfield, strbuf);
1007         strncpy(rtnStr, strbuf, strlen(strbuf));
1008 }
1009
1010 void _msg_smil_cont_mgr_get_media_int_value(msg_struct_t media_info_t, int intfield, int* rtnVal)
1011 {
1012         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
1013         MSG_UI_RET_IF(MSG_UI_LEVEL_ERR, media_info_t == NULL);
1014
1015         if (intfield != MSG_MMS_MEDIA_TYPE_INT && intfield != MSG_MMS_MEDIA_DRM_TYPE_INT) {
1016                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "field value(%d) is not INT type", intfield);
1017                 return;
1018         }
1019
1020         if (intfield == MSG_MMS_MEDIA_TYPE_INT)
1021                 msg_get_int_value(media_info_t, MSG_MMS_MEDIA_TYPE_INT, rtnVal);
1022         else if (intfield == MSG_MMS_MEDIA_DRM_TYPE_INT)
1023                 msg_get_int_value(media_info_t, MSG_MMS_MEDIA_DRM_TYPE_INT, rtnVal);
1024
1025         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "field value(%d) is %d", intfield, *rtnVal);
1026 }
1027
1028 msg_struct_t    _msg_smil_cont_mgr_get_mms_body_struct_handle(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle)
1029 {
1030         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
1031         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, NULL);
1032         return smilContMgrHndle->msg_info_t;
1033 }
1034
1035 MSG_BOOL _msg_smil_cont_mgr_get_slide_time(SMIL_CONTENT_MGR_HANDLE_S *smilContMgrHndle, int slideIdx, MSG_BOOL bExcludeHp, double *time)
1036 {
1037         MSG_UI_ENTER(MSG_UI_LEVEL_DEBUG);
1038         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle == NULL, FALSE);
1039         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, smilContMgrHndle->smilContent == NULL, FALSE);
1040
1041         SMIL_SLIDE_INFO_S *curSlide = _msg_smil_cont_mgr_get_slide(smilContMgrHndle, 0);
1042         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, curSlide == NULL, FALSE);
1043         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, curSlide->commonData == NULL, FALSE);
1044         MSG_UI_RETV_IF(MSG_UI_LEVEL_ERR, curSlide->pageInfo == NULL, FALSE);
1045
1046         MSG_BOOL is_mixed_msg = FALSE;
1047         double total_time = 0;
1048         char szFilePath[MSG_FILEPATH_LEN_MAX] = {0,};
1049         msg_list_handle_t page_list_info = NULL;
1050         msg_struct_t page_info = NULL;
1051
1052         is_mixed_msg = (curSlide->commonData->pageCnt == 0) ? TRUE : FALSE;
1053
1054         //check validity input page index
1055         if ((curSlide =_msg_smil_cont_mgr_get_slide(smilContMgrHndle, slideIdx)) == NULL) {
1056                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "Current msg is Multipart related msg, but there's no page with given index (%d)!", slideIdx);
1057                 return FALSE;
1058         }
1059
1060         if (is_mixed_msg) {
1061                 if (slideIdx != 0) {
1062                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "Mixed msg cannot have 1 more page!");
1063                         return FALSE;
1064                 }
1065                 total_time = (double)MSG_MMS_SMIL_HELP_PAGE_DURATION;
1066         } else {
1067                 while (slideIdx < curSlide->commonData->pageCnt) {
1068                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "slideIdx = %d", slideIdx);
1069                         double pagetime = 0.0;
1070                         char *value = NULL;
1071                         int duration = 0;
1072                         double maximum_time = 0.0;
1073
1074                         curSlide =_msg_smil_cont_mgr_get_slide(smilContMgrHndle, slideIdx);
1075
1076                         if (curSlide == NULL || curSlide->pageInfo == NULL) {
1077                                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "curSlide is NULL or pageInfo in curSlide is NULL!");
1078                                 return FALSE;
1079                         }
1080
1081                         if (bExcludeHp && curSlide->pageInfo->isHelpPage) {
1082                                 if (slideIdx == 0 && curSlide->commonData->pageCnt == 1) {
1083                                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "Total page count = 1, And if there's only 1 help page, set default time for duration.");
1084                                         total_time = (double)MSG_MMS_SMIL_HELP_PAGE_DURATION;
1085                                         break;
1086                                 } else {
1087                                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "current page(%d) is Help page and bExcludeHp flag is %d, skip calculating this page", curSlide->pageIdx, bExcludeHp);
1088                                         slideIdx++;
1089                                         continue;
1090                                 }
1091                         }
1092                         //set pagetime as duration time
1093                         pagetime = (double)(curSlide->pageInfo->pageDuration);
1094
1095                         // get media time value for pagetime is not valid
1096                         if (pagetime < 0) {
1097                                 /*Get Media List.*/
1098                                 page_list_info = _msg_smil_cont_mgr_get_page_list_handle(smilContMgrHndle);
1099                                 if (page_list_info)
1100                                         page_info = _msg_smil_cont_mgr_get_nth_page_struct_handle(page_list_info, curSlide->pageIdx);
1101
1102                                 if (page_info && curSlide->pageInfo->mediaCnt > 0) {
1103                                         int index = 0;
1104                                         int mediaCnt = 0;
1105                                         msg_list_handle_t media_list_info = _msg_smil_cont_mgr_get_page_media_list_handle(page_info);
1106                                         mediaCnt = msg_list_length(media_list_info);
1107
1108                                         while (index < mediaCnt) {
1109                                                 int mediaType = 0;
1110                                                 msg_struct_t media_info = _msg_smil_cont_mgr_get_page_nth_media_struct_handle(media_list_info, index);
1111
1112                                                 if (media_info == NULL) {
1113                                                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "media_info is Null");
1114                                                         return FALSE;
1115                                                 }
1116
1117                                                 bzero(szFilePath, sizeof(szFilePath));
1118                                                 _msg_smil_cont_mgr_get_media_str_value(media_info, MSG_MMS_MEDIA_FILEPATH_STR, szFilePath);
1119                                                 _msg_smil_cont_mgr_get_media_int_value(media_info, MSG_MMS_MEDIA_TYPE_INT, &mediaType);
1120
1121                                                 if (mediaType == MMS_SMIL_MEDIA_VIDEO ||
1122                                                         mediaType == MMS_SMIL_MEDIA_AUDIO ||
1123                                                         mediaType == MMS_SMIL_MEDIA_IMG_OR_VIDEO) {
1124                                                         bool is_drm = FALSE;
1125                                                         bool is_available_play = FALSE;
1126
1127                                                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "mediaType = %d", mediaType);
1128
1129                                                         //check DRM
1130                                                         drm_bool_type_e is_drm_file = DRM_UNKNOWN;
1131                                                         int ret = DRM_RETURN_SUCCESS;
1132
1133                                                         ret = drm_is_drm_file(szFilePath, &is_drm_file);
1134                                                         is_drm = (ret == DRM_RETURN_SUCCESS && is_drm_file == DRM_TRUE) ? TRUE : FALSE;
1135                                                         if (is_drm) {
1136                                                                 int ret = DRM_RETURN_SUCCESS;
1137                                                                 drm_license_status_e license_status = DRM_LICENSE_STATUS_UNDEFINED;
1138                                                                 ret = drm_get_license_status(szFilePath, DRM_PERMISSION_TYPE_PLAY, &license_status);
1139                                                                 if (ret != DRM_RETURN_SUCCESS) {
1140                                                                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "drm_get_license_status is failed ret = %d", ret);
1141                                                                         is_available_play = FALSE;
1142                                                                 }
1143
1144                                                                 if (license_status != DRM_LICENSE_STATUS_VALID) {
1145                                                                         MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "license_status = %d", license_status);
1146                                                                         is_available_play = FALSE;
1147                                                                 } else {
1148                                                                         is_available_play = TRUE;
1149                                                                 }
1150                                                         } else {
1151                                                                 is_available_play = TRUE;
1152                                                         }
1153
1154                                                         if (is_available_play) {
1155                                                                 int ret = 0;
1156                                                                 metadata_extractor_h handle = NULL;
1157                                                                 ret = metadata_extractor_create(&handle);
1158
1159                                                                 if (ret == METADATA_EXTRACTOR_ERROR_NONE) {
1160                                                                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "tempMedia->szFilePath is %s", szFilePath);
1161                                                                         ret = metadata_extractor_set_path(handle, szFilePath);
1162                                                                         if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
1163                                                                                 MSG_UI_DEBUG(MSG_UI_LEVEL_ERR, "metadata_extractor_set_path is failed, %d", ret);
1164                                                                                 metadata_extractor_destroy(handle);
1165                                                                                 return FALSE;
1166                                                                         }
1167
1168                                                                         ret = metadata_extractor_get_metadata(handle, METADATA_DURATION, &value);
1169
1170                                                                         if (ret == METADATA_EXTRACTOR_ERROR_NONE) {
1171                                                                                 if (value) {
1172                                                                                         duration = atoi(value);
1173                                                                                         free(value);
1174                                                                                 }
1175                                                                         } else {
1176                                                                                 MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "metadata_extractor_get_metadata is failed - ret(%x)", ret);
1177                                                                                 metadata_extractor_destroy(handle);
1178                                                                                 return FALSE;
1179                                                                         }
1180
1181                                                                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "file : %s, duration : %f", szFilePath, (double)duration);
1182
1183                                                                         metadata_extractor_destroy(handle);
1184                                                                 } else {
1185                                                                         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "metadata_extractor_create is failed - ret(%x)", ret);
1186                                                                 }
1187                                                         }
1188
1189                                                         //ceiling duration time
1190                                                         double ceilvalue = ceil((double)duration/1000)*1000;
1191                                                         if (maximum_time <= ceilvalue)
1192                                                                 maximum_time = ceilvalue;
1193                                                 }
1194
1195                                                 index++;
1196                                         }
1197                                 }
1198
1199                                 pagetime = maximum_time;
1200                         }
1201
1202                         total_time += pagetime;
1203
1204                         slideIdx++;
1205                 }
1206         }
1207
1208         *time = total_time;
1209
1210         MSG_UI_DEBUG(MSG_UI_LEVEL_DEBUG, "total slide time is %f", *time);
1211
1212         return TRUE;
1213 }