mapi/msg_mms.cpp

   1 /*
   2 * Copyright 2012-2013  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 #include <stdio.h>
  18 #include <string.h>
  19
  20 #include <MsgHandle.h>
  21 #include <MsgException.h>
  22 #include "MsgTypes.h"
  23 #include "MsgMmsTypes.h"
  24 #include "MsgMmsMessage.h"
  25 #include "MsgDebug.h"
  26
  27 #include "msg.h"
  28 #include "msg_private.h"
  29
  30 //Internel Struct
  31 typedef struct _MMS_DATA_S
  32 {
  33         GList                   *pagelist;
  34         GList                   *regionlist;
  35         GList                   *attachlist;
  36         GList                   *transitionlist;
  37         GList                   *metalist;
  38         MMS_SMIL_ROOTLAYOUT     rootlayout;
  39         MMS_APPID_INFO_S        msgAppId;
  40 } MMS_DATA_HIDDEN_S;
  41
  42 typedef struct
  43 {
  44         MmsSmilMediaType        mediatype; /**< Indicates the SMIL media type. see enum MmsSmilMediaType */
  45
  46         char                    szSrc[MSG_FILEPATH_LEN_MAX + 1];/**< Indicates the media source name */
  47         char                    szFileName[MSG_FILENAME_LEN_MAX + 1]; /**< Indicates the file name */
  48         char                    szFilePath[MSG_FILEPATH_LEN_MAX + 1]; /**< Indicates the file path */
  49         char                    szContentID[MSG_MSG_ID_LEN + 1]; /**< Indicates the content id */
  50         char                    regionId[MAX_SMIL_REGION_ID + 1]; /**< Indicates the region id */
  51         char                    szAlt[MAX_SMIL_ALT_LEN + 1]; /**< Indicates the alternative text to be displayed in failure case */
  52         MsgDrmType              drmType; /**< Indicates the drm type. see enum MsgDrmType */
  53         char                    szDrm2FullPath[MSG_FILEPATH_LEN_MAX + 1];  /**< Indicates the fullpath of the DRM */
  54         msg_struct_s *pText;
  55         msg_struct_s *pAVI;
  56 } MMS_MEDIA_HIDDEN_S;
  57
  58 static void __msg_mms_release_mms(msg_struct_s *mms_struct);
  59 static void __msg_mms_release_page(msg_struct_s *page_struct);
  60 static void __msg_mms_release_media(msg_struct_s *media_struct);
  61 static void __msg_mms_release_region(msg_struct_s *region_struct);
  62 static void __msg_mms_release_attach(msg_struct_s *attach_struct);
  63 static void __msg_mms_release_transition(msg_struct_s *transition_struct);
  64 static void __msg_mms_release_meta(msg_struct_s *meta_struct);
  65
  66 /*==================================================================================================
  67                                      FUNCTION IMPLEMENTATION
  68 ==================================================================================================*/
  69 static void __removeLessGreaterMark(const char *szSrcID, char *szDest, int destSize)
  70 {
  71         char szBuf[MSG_MSG_ID_LEN + 1] = {0, };
  72         int cLen = strlen(szSrcID);
  73
  74         if (cLen == 0)
  75                 return;
  76
  77         if (cLen > 1 && szSrcID[0] == '<' && szSrcID[cLen - 1] == '>') {
  78                 strncpy(szBuf, &szSrcID[1], cLen - 2);
  79                 szBuf[cLen - 2] = '\0';
  80         } else if (cLen > 1 && szSrcID[0] == '"' && szSrcID[cLen-1] == '"') {
  81                 strncpy(szBuf, &szSrcID[1], cLen - 2);
  82                 szBuf[cLen - 2] = '\0';
  83         } else {
  84                 strncpy(szBuf, szSrcID, cLen);
  85                 szBuf[cLen] = '\0';
  86         }
  87
  88         snprintf(szDest, destSize, "%s", szBuf);
  89 }
  90
  91 static inline void *get_msg_struct_data(msg_struct_s *msg_struct)
  92 {
  93         if (msg_struct == NULL)
  94                 return NULL;
  95
  96         return msg_struct->data;
  97 }
  98
  99 msg_struct_s *msg_mms_create_struct(int type)
 100 {
 101         msg_struct_s *msg_struct = new msg_struct_s;
 102         bzero(msg_struct, sizeof(msg_struct_s));
 103
 104         msg_struct->type = type;
 105         msg_struct->data = msg_mms_create_struct_data(type);
 106
 107         return msg_struct;
 108 }
 109
 110 void *msg_mms_create_struct_data(int field)
 111 {
 112         void *data = NULL;
 113
 114         switch(field)
 115         {
 116         case MSG_STRUCT_MMS:
 117                 data = (void *)new MMS_DATA_HIDDEN_S;
 118                 bzero(data, sizeof(MMS_DATA_HIDDEN_S));
 119                 break;
 120         case MSG_STRUCT_MMS_PAGE:
 121                 data = (void *)new MMS_PAGE_S;
 122                 bzero(data, sizeof(MMS_PAGE_S));
 123                 break;
 124         case MSG_STRUCT_MMS_MEDIA:
 125         {
 126                 MMS_MEDIA_HIDDEN_S *media = new MMS_MEDIA_HIDDEN_S;
 127                 bzero(media, sizeof(MMS_MEDIA_HIDDEN_S));
 128
 129                 media->pText = msg_mms_create_struct(MSG_STRUCT_MMS_SMIL_TEXT);
 130                 media->pAVI = msg_mms_create_struct(MSG_STRUCT_MMS_SMIL_AVI);
 131                 data = (void *)media;
 132         }
 133                 break;
 134         case MSG_STRUCT_MMS_ATTACH:
 135                 data = (void *)new MMS_ATTACH_S;
 136                 bzero(data, sizeof(MMS_ATTACH_S));
 137                 break;
 138         case MSG_STRUCT_MMS_REGION:
 139                 data = (void *)new MMS_SMIL_REGION;
 140                 bzero(data, sizeof(MMS_SMIL_REGION));
 141                 ((MMS_SMIL_REGION *)data)->fit = MMSUI_IMAGE_REGION_FIT_MEET;
 142                 break;
 143         case MSG_STRUCT_MMS_TRANSITION:
 144                 data = (void *)new MMS_SMIL_TRANSITION;
 145                 bzero(data, sizeof(MMS_SMIL_TRANSITION));
 146                 break;
 147         case MSG_STRUCT_MMS_META:
 148                 data = (void *)new MMS_SMIL_META;
 149                 bzero(data, sizeof(MMS_SMIL_META));
 150                 break;
 151         case MSG_STRUCT_MMS_SMIL_TEXT:
 152                 data = (void *)new MmsSmilText;
 153                 bzero(data, sizeof(MmsSmilText));
 154                 break;
 155         case MSG_STRUCT_MMS_SMIL_AVI:
 156                 data = (void *)new MmsSmilAVI;
 157                 bzero(data, sizeof(MmsSmilAVI));
 158                 break;
 159         }
 160
 161         return data;
 162 }
 163
 164 void msg_mms_list_item_free_func(gpointer data)
 165 {
 166         msg_struct_s *msg_struct = (msg_struct_s *)data;
 167         if (msg_struct->type == MSG_STRUCT_MMS_MEDIA)  {
 168                 __msg_mms_release_media(msg_struct);
 169         } else if (msg_struct->type == MSG_STRUCT_MMS_PAGE) {
 170                 __msg_mms_release_page(msg_struct);
 171         } else if (msg_struct->type == MSG_STRUCT_MMS_ATTACH) {
 172                 __msg_mms_release_attach(msg_struct);
 173         } else if (msg_struct->type == MSG_STRUCT_MMS_REGION) {
 174                 __msg_mms_release_region(msg_struct);
 175         } else if (msg_struct->type == MSG_STRUCT_MMS_TRANSITION) {
 176                 __msg_mms_release_transition(msg_struct);
 177         } else if (msg_struct->type == MSG_STRUCT_MMS_META) {
 178                 __msg_mms_release_meta(msg_struct);
 179         }
 180 }
 181
 182 void __msg_mms_release_page(msg_struct_s *page_struct)
 183 {
 184         MMS_PAGE_S *page = (MMS_PAGE_S *)page_struct->data;
 185         if (page->medialist) {
 186                  g_list_free_full(page->medialist, msg_mms_list_item_free_func);
 187         }
 188
 189         delete (MMS_PAGE_S *)page;
 190         page_struct->data = NULL;
 191
 192         delete page_struct;
 193 }
 194
 195 void __msg_mms_release_media(msg_struct_s *media_struct)
 196 {
 197         MMS_MEDIA_HIDDEN_S *media = (MMS_MEDIA_HIDDEN_S *)media_struct->data;
 198
 199         if (media->pText)
 200                 msg_mms_release_struct(&media->pText);
 201
 202         if (media->pAVI)
 203                 msg_mms_release_struct(&media->pAVI);
 204
 205         delete (MMS_MEDIA_HIDDEN_S *)media;
 206
 207         media_struct->data = NULL;
 208
 209         delete media_struct;
 210 }
 211
 212 void __msg_mms_release_attach(msg_struct_s *attach_struct)
 213 {
 214         MMS_ATTACH_S *attach = (MMS_ATTACH_S *)attach_struct->data;
 215
 216         delete (MMS_ATTACH_S *)attach;
 217
 218         attach_struct->data = NULL;
 219
 220         delete attach_struct;
 221 }
 222
 223 void __msg_mms_release_region(msg_struct_s *region_struct)
 224 {
 225         MMS_SMIL_REGION *region = (MMS_SMIL_REGION *)region_struct->data;
 226
 227         delete (MMS_SMIL_REGION *)region;
 228
 229         region_struct->data = NULL;
 230
 231         delete region_struct;
 232 }
 233
 234 void __msg_mms_release_transition(msg_struct_s *transition_struct)
 235 {
 236         MMS_SMIL_TRANSITION *transition = (MMS_SMIL_TRANSITION *)transition_struct->data;
 237
 238         delete (MMS_SMIL_TRANSITION *)transition;
 239
 240         transition_struct->data = NULL;
 241
 242         delete transition_struct;
 243 }
 244
 245 void __msg_mms_release_meta(msg_struct_s *meta_struct)
 246 {
 247         MMS_SMIL_META *meta = (MMS_SMIL_META *)meta_struct->data;
 248
 249         delete (MMS_SMIL_META *)meta;
 250
 251         meta_struct->data = NULL;
 252
 253         delete meta_struct;
 254 }
 255
 256 void __msg_mms_release_mms(msg_struct_s *mms_struct)
 257 {
 258         MMS_DATA_HIDDEN_S *mms = (MMS_DATA_HIDDEN_S *)mms_struct->data;
 259
 260         if (mms->pagelist) {
 261                 g_list_free_full(mms->pagelist, msg_mms_list_item_free_func);
 262                 mms->pagelist = NULL;
 263         }
 264
 265         if (mms->regionlist) {
 266                 g_list_free_full(mms->regionlist, msg_mms_list_item_free_func);
 267                 mms->regionlist = NULL;
 268         }
 269
 270         if (mms->attachlist) {
 271                 g_list_free_full(mms->attachlist, msg_mms_list_item_free_func);
 272                 mms->attachlist = NULL;
 273         }
 274
 275         if (mms->transitionlist) {
 276                 g_list_free_full(mms->transitionlist, msg_mms_list_item_free_func);
 277                 mms->transitionlist = NULL;
 278         }
 279
 280         if (mms->metalist) {
 281                 g_list_free_full(mms->metalist, msg_mms_list_item_free_func);
 282                 mms->metalist = NULL;
 283         }
 284
 285         delete (MMS_DATA_HIDDEN_S *)mms;
 286
 287         mms_struct->data = NULL;
 288
 289         delete mms_struct;
 290 }
 291
 292 int msg_mms_release_struct(msg_struct_s **msg_struct_data)
 293 {
 294         msg_struct_s *msg_struct = (msg_struct_s *)*msg_struct_data;
 295         int type = msg_struct->type;
 296
 297         switch(type)
 298         {
 299         case MSG_STRUCT_MMS:
 300                 __msg_mms_release_mms(*msg_struct_data);
 301                 *msg_struct_data = NULL;
 302                 break;
 303         case MSG_STRUCT_MMS_PAGE:
 304                 __msg_mms_release_page(*msg_struct_data);
 305                 *msg_struct_data = NULL;
 306                 break;
 307         case MSG_STRUCT_MMS_MEDIA:
 308                 __msg_mms_release_media(*msg_struct_data);
 309                 *msg_struct_data = NULL;
 310                 break;
 311         case MSG_STRUCT_MMS_ATTACH:
 312                 __msg_mms_release_attach(*msg_struct_data);
 313                 *msg_struct_data = NULL;
 314                 break;
 315         case MSG_STRUCT_MMS_REGION:
 316                 __msg_mms_release_attach(*msg_struct_data);
 317                 *msg_struct_data = NULL;
 318                 break;
 319         case MSG_STRUCT_MMS_TRANSITION:
 320                 __msg_mms_release_transition(*msg_struct_data);
 321                 *msg_struct_data = NULL;
 322                 break;
 323         case MSG_STRUCT_MMS_META:
 324                 __msg_mms_release_meta(*msg_struct_data);
 325                 *msg_struct_data = NULL;
 326                 break;
 327         case MSG_STRUCT_MMS_SMIL_TEXT:
 328                 delete (MmsSmilText*)msg_struct->data;
 329                 delete msg_struct;
 330                 *msg_struct_data = NULL;
 331                 break;
 332         case MSG_STRUCT_MMS_SMIL_AVI:
 333                 delete (MmsSmilAVI*)msg_struct->data;
 334                 delete msg_struct;
 335                 *msg_struct_data = NULL;
 336                 break;
 337         }
 338
 339         return 0;
 340 }
 341
 342 int msg_mms_get_int_value(msg_struct_s *msg_struct, int field, int *value)
 343 {
 344         msg_error_t err = MSG_SUCCESS;
 345
 346         switch(msg_struct->type) {
 347         case MSG_STRUCT_MMS:
 348         {
 349                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
 350                 if (field == MSG_MMS_ROOTLAYOUT_WIDTH_INT)
 351                         *value = mms_data->rootlayout.width.value;
 352                 else if (field == MSG_MMS_ROOTLAYOUT_HEIGHT_INT)
 353                         *value = mms_data->rootlayout.height.value;
 354                 else if (field == MSG_MMS_ROOTLAYOUT_BGCOLOR_INT)
 355                         *value = mms_data->rootlayout.bgColor;
 356                 else
 357                         err = MSG_ERR_INVALID_PARAMETER;
 358         }
 359         break;
 360         case MSG_STRUCT_MMS_PAGE:
 361         {
 362                 MMS_PAGE_S *mms_page_data = (MMS_PAGE_S *)msg_struct->data;
 363                 if (field == MSG_MMS_PAGE_PAGE_DURATION_INT)
 364                         *value = mms_page_data->nDur;
 365                 else if (field == MSG_MMS_PAGE_BEGIN_TIME_INT)
 366                         *value = mms_page_data->nBegin;
 367                 else if (field == MSG_MMS_PAGE_END_TIME_INT)
 368                         *value = mms_page_data->nEnd;
 369                 else if (field == MSG_MMS_PAGE_MIN_INT)
 370                         *value = mms_page_data->nMin;
 371                 else if (field == MSG_MMS_PAGE_MAX_INT)
 372                         *value = mms_page_data->nMax;
 373                 else if (field == MSG_MMS_PAGE_REPEAT_INT)
 374                         *value = mms_page_data->nRepeat;
 375                 else
 376                         err = MSG_ERR_INVALID_PARAMETER;
 377         }
 378         break;
 379         case MSG_STRUCT_MMS_MEDIA:
 380         {
 381                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
 382                 if (field == MSG_MMS_MEDIA_TYPE_INT)
 383                         *value = mms_media_data->mediatype;
 384                 else if (field == MSG_MMS_MEDIA_DRM_TYPE_INT)
 385                         *value = mms_media_data->drmType;
 386                 else
 387                         err = MSG_ERR_INVALID_PARAMETER;
 388         }
 389         break;
 390         case MSG_STRUCT_MMS_ATTACH:
 391         {
 392                 MMS_ATTACH_S *mms_attach_data = (MMS_ATTACH_S *)msg_struct->data;
 393                 if (field == MSG_MMS_ATTACH_MIME_TYPE_INT)
 394                         *value = mms_attach_data->mediatype;
 395                 else if (field == MSG_MMS_ATTACH_FILESIZE_INT)
 396                         *value = mms_attach_data->fileSize;
 397                 else if (field == MSG_MMS_ATTACH_DRM_TYPE_INT)
 398                         *value = mms_attach_data->drmType;
 399                 else
 400                         err = MSG_ERR_INVALID_PARAMETER;
 401         }
 402         break;
 403         case MSG_STRUCT_MMS_REGION:
 404         {
 405                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
 406                 if (field == MSG_MMS_REGION_LENGTH_LEFT_INT)
 407                         *value = mms_region_data->nLeft.value;
 408                 else if (field == MSG_MMS_REGION_LENGTH_TOP_INT)
 409                         *value = mms_region_data->nTop.value;
 410                 else if (field == MSG_MMS_REGION_LENGTH_WIDTH_INT)
 411                         *value = mms_region_data->width.value;
 412                 else if (field == MSG_MMS_REGION_LENGTH_HEIGHT_INT)
 413                         *value = mms_region_data->height.value;
 414                 else if (field == MSG_MMS_REGION_BGCOLOR_INT)
 415                         *value = mms_region_data->bgColor;
 416                 else if (field == MSG_MMS_REGION_FIT_TYPE_INT)
 417                         *value = mms_region_data->fit;
 418                 else
 419                         err = MSG_ERR_INVALID_PARAMETER;
 420         }
 421         break;
 422         case MSG_STRUCT_MMS_TRANSITION:
 423         {
 424                 MMS_SMIL_TRANSITION *mms_transition_data = (MMS_SMIL_TRANSITION *)msg_struct->data;
 425                 if (field == MSG_MMS_TRANSITION_TYPE_INT)
 426                         *value = mms_transition_data->nType;
 427                 else if (field == MSG_MMS_TRANSITION_SUBTYPE_INT)
 428                         *value = mms_transition_data->nSubType;
 429                 else if (field == MSG_MMS_TRANSITION_DURATION_INT)
 430                         *value = mms_transition_data->nDur;
 431                 else
 432                         err = MSG_ERR_INVALID_PARAMETER;
 433         }
 434         break;
 435         case MSG_STRUCT_MMS_SMIL_TEXT:
 436         {
 437                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
 438                 if (field == MSG_MMS_SMIL_TEXT_REPEAT_INT)
 439                         *value = mms_smil_text_data->nRepeat;
 440                 else if (field == MSG_MMS_SMIL_TEXT_BEGIN_INT)
 441                         *value = mms_smil_text_data->nBegin;
 442                 else if (field == MSG_MMS_SMIL_TEXT_END_INT)
 443                         *value = mms_smil_text_data->nEnd;
 444                 else if (field == MSG_MMS_SMIL_TEXT_DURTIME_INT)
 445                         *value = mms_smil_text_data->nDurTime;
 446                 else if (field == MSG_MMS_SMIL_TEXT_BGCOLOR_INT)
 447                         *value = mms_smil_text_data->nBgColor;
 448                 else if (field == MSG_MMS_SMIL_TEXT_DIRECTION_TYPE_INT)
 449                         *value = mms_smil_text_data->nDirection;
 450                 else if (field == MSG_MMS_SMIL_TEXT_SIZE_INT)
 451                         *value = mms_smil_text_data->nSize;
 452                 else if (field == MSG_MMS_SMIL_TEXT_COLOR_INT)
 453                         *value = mms_smil_text_data->nColor;
 454                 else
 455                         err = MSG_ERR_INVALID_PARAMETER;
 456         }
 457         break;
 458         case MSG_STRUCT_MMS_SMIL_AVI:
 459         {
 460                 MmsSmilAVI *mms_smil_avi_data = (MmsSmilAVI *)msg_struct->data;
 461                 if (field == MSG_MMS_SMIL_AVI_REPEAT_INT)
 462                         *value = mms_smil_avi_data->nRepeat;
 463                 else if (field == MSG_MMS_SMIL_AVI_BEGIN_INT)
 464                         *value = mms_smil_avi_data->nBegin;
 465                 else if (field == MSG_MMS_SMIL_AVI_END_INT)
 466                         *value = mms_smil_avi_data->nEnd;
 467                 else if (field == MSG_MMS_SMIL_AVI_DURTIME_INT)
 468                         *value = mms_smil_avi_data->nDurTime;
 469                 else if (field == MSG_MMS_SMIL_AVI_BGCOLOR_INT)
 470                         *value = mms_smil_avi_data->nBgColor;
 471                 else
 472                         err = MSG_ERR_INVALID_PARAMETER;
 473         }
 474         break;
 475         default :
 476                 err = MSG_ERR_INVALID_PARAMETER;
 477                 break;
 478         }
 479         return MSG_SUCCESS;
 480 }
 481
 482 int msg_mms_get_str_value(msg_struct_s *msg_struct, int field, char *value, int size)
 483 {
 484         msg_error_t err = MSG_SUCCESS;
 485
 486         switch(msg_struct->type) {
 487         case MSG_STRUCT_MMS_MEDIA:
 488         {
 489                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
 490                 if (field == MSG_MMS_MEDIA_SRC_STR)
 491                         strncpy(value, mms_media_data->szSrc, size);
 492                 else if (field == MSG_MMS_MEDIA_FILENAME_STR)
 493                         strncpy(value, mms_media_data->szFileName, size);
 494                 else if (field == MSG_MMS_MEDIA_FILEPATH_STR)
 495                         strncpy(value, mms_media_data->szFilePath, size);
 496                 else if (field == MSG_MMS_MEDIA_CONTENT_ID_STR) {
 497                         if (strlen(mms_media_data->szContentID) > 0)
 498                                 snprintf(value, size, "<%s>", mms_media_data->szContentID);
 499                 }else if (field == MSG_MMS_MEDIA_REGION_ID_STR)
 500                         strncpy(value, mms_media_data->regionId, size);
 501                 else if (field == MSG_MMS_MEDIA_ALTERNATIVE_STR)
 502                         strncpy(value, mms_media_data->szAlt, size);
 503                 else if (field == MSG_MMS_MEDIA_DRM_FULLPATH_STR)
 504                         strncpy(value, mms_media_data->szDrm2FullPath, size);
 505                 else
 506                         err = MSG_ERR_INVALID_PARAMETER;
 507         }
 508         break;
 509         case MSG_STRUCT_MMS_ATTACH:
 510         {
 511                 MMS_ATTACH_S *mms_attach_data = (MMS_ATTACH_S *)msg_struct->data;
 512                 if (field == MSG_MMS_ATTACH_FILENAME_STR)
 513                         strncpy(value, mms_attach_data->szFileName, size);
 514                 else if (field == MSG_MMS_ATTACH_FILEPATH_STR)
 515                         strncpy(value, mms_attach_data->szFilePath, size);
 516                 else if (field == MSG_MMS_ATTACH_DRM_FULLPATH_STR)
 517                         strncpy(value, mms_attach_data->szDrm2FullPath, size);
 518                 else
 519                         err = MSG_ERR_INVALID_PARAMETER;
 520         }
 521         break;
 522         case MSG_STRUCT_MMS_REGION:
 523         {
 524                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
 525                 if (field == MSG_MMS_REGION_ID_STR)
 526                         strncpy(value, mms_region_data->szID, size);
 527                 else
 528                         err = MSG_ERR_INVALID_PARAMETER;
 529         }
 530         break;
 531         case MSG_STRUCT_MMS_TRANSITION:
 532         {
 533                 MMS_SMIL_TRANSITION *mms_transition_data = (MMS_SMIL_TRANSITION *)msg_struct->data;
 534                 if (field == MSG_MMS_TRANSITION_ID_STR)
 535                         strncpy(value, mms_transition_data->szID, size);
 536                 else
 537                         err = MSG_ERR_INVALID_PARAMETER;
 538         }
 539         break;
 540         case MSG_STRUCT_MMS_META:
 541         {
 542                 MMS_SMIL_META *mms_meta_data = (MMS_SMIL_META *)msg_struct->data;
 543                 if (field == MSG_MMS_META_ID_STR)
 544                         strncpy(value, mms_meta_data->szID, size);
 545                 else if (field == MSG_MMS_META_NAME_STR)
 546                         strncpy(value, mms_meta_data->szName, size);
 547                 else if (field == MSG_MMS_META_CONTENT_STR)
 548                         strncpy(value, mms_meta_data->szContent, size);
 549                 else
 550                         err = MSG_ERR_INVALID_PARAMETER;
 551         }
 552         break;
 553         case MSG_STRUCT_MMS_SMIL_TEXT:
 554         {
 555                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
 556                 if (field == MSG_MMS_SMIL_TEXT_TRANSITION_IN_ID_STR)
 557                         strncpy(value, mms_smil_text_data->szTransInId, size);
 558                 else if (field == MSG_MMS_SMIL_TEXT_TRANSITION_OUT_ID_STR)
 559                         strncpy(value, mms_smil_text_data->szTransOutId, size);
 560                 else
 561                         err = MSG_ERR_INVALID_PARAMETER;
 562         }
 563         break;
 564         case MSG_STRUCT_MMS_SMIL_AVI:
 565         {
 566                 MmsSmilAVI *mms_smil_avi_data = (MmsSmilAVI *)msg_struct->data;
 567                 if (field == MSG_MMS_SMIL_AVI_TRANSITION_IN_ID_STR)
 568                         strncpy(value, mms_smil_avi_data->szTransInId, size);
 569                 else if (field == MSG_MMS_SMIL_AVI_TRANSITION_OUT_ID_STR)
 570                         strncpy(value, mms_smil_avi_data->szTransOutId, size);
 571                 else
 572                         err = MSG_ERR_INVALID_PARAMETER;
 573         }
 574         break;
 575         default :
 576                         err = MSG_ERR_INVALID_PARAMETER;
 577                 break;
 578         }
 579         return MSG_SUCCESS;
 580 }
 581
 582 int msg_mms_get_bool_value(msg_struct_s *msg_struct, int field, bool *value)
 583 {
 584         msg_error_t err = MSG_SUCCESS;
 585
 586         switch(msg_struct->type) {
 587         case MSG_STRUCT_MMS:
 588         {
 589                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
 590                 if (field == MSG_MMS_ROOTLAYOUT_WIDTH_PERCENT_BOOL)
 591                         *value = mms_data->rootlayout.width.bUnitPercent;
 592                 else if (field == MSG_MMS_ROOTLAYOUT_HEIGHT_PERCENT_BOOL)
 593                         *value = mms_data->rootlayout.height.bUnitPercent;
 594                 else if (field == MSG_MMS_ROOTLAYOUT_BGCOLOR_BOOL)
 595                         *value = mms_data->rootlayout.bBgColor;
 596                 else
 597                         err = MSG_ERR_INVALID_PARAMETER;
 598         }
 599         break;
 600         case MSG_STRUCT_MMS_REGION:
 601         {
 602                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
 603                 if (field == MSG_MMS_REGION_LENGTH_LEFT_PERCENT_BOOL)
 604                         *value = mms_region_data->nLeft.bUnitPercent;
 605                 else if (field == MSG_MMS_REGION_LENGTH_TOP_PERCENT_BOOL)
 606                         *value = mms_region_data->nTop.bUnitPercent;
 607                 else if (field == MSG_MMS_REGION_LENGTH_WIDTH_PERCENT_BOOL)
 608                         *value = mms_region_data->width.bUnitPercent;
 609                 else if (field == MSG_MMS_REGION_LENGTH_HEIGHT_PERCENT_BOOL)
 610                         *value = mms_region_data->height.bUnitPercent;
 611                 else if (field == MSG_MMS_REGION_BGCOLOR_BOOL)
 612                         *value = mms_region_data->bBgColor;
 613                 else
 614                         err = MSG_ERR_INVALID_PARAMETER;
 615         }
 616         break;
 617         case MSG_STRUCT_MMS_SMIL_TEXT:
 618         {
 619                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
 620                 if (field == MSG_MMS_SMIL_TEXT_BOLD_BOOL)
 621                         *value = mms_smil_text_data->bBold;
 622                 else if (field == MSG_MMS_SMIL_TEXT_UNDERLINE_BOOL)
 623                         *value = mms_smil_text_data->bUnderLine;
 624                 else if (field == MSG_MMS_SMIL_TEXT_ITALIC_BOOL)
 625                         *value = mms_smil_text_data->bItalic;
 626                 else if (field == MSG_MMS_SMIL_TEXT_REVERSE_BOOL)
 627                         *value = mms_smil_text_data->bReverse;
 628                 else
 629                         err = MSG_ERR_INVALID_PARAMETER;
 630         }
 631         break;
 632         default :
 633                 err = MSG_ERR_INVALID_PARAMETER;
 634                 break;
 635         }
 636         return MSG_SUCCESS;
 637 }
 638
 639 int msg_mms_get_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s **value)
 640 {
 641         msg_error_t err = MSG_SUCCESS;
 642
 643         switch(msg_struct->type) {
 644         case MSG_STRUCT_MMS_MEDIA:
 645         {
 646                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
 647                 if (field == MSG_MMS_MEDIA_SMIL_TEXT_HND)
 648                         *value = mms_media_data->pText;
 649                 else if (field == MSG_MMS_MEDIA_SMIL_AVI_HND)
 650                         *value = mms_media_data->pAVI;
 651                 else
 652                         err = MSG_ERR_INVALID_PARAMETER;
 653         }
 654         break;
 655         default :
 656                 err = MSG_ERR_INVALID_PARAMETER;
 657                 break;
 658         }
 659         return MSG_SUCCESS;
 660 }
 661
 662 int msg_mms_get_list_handle(msg_struct_s *msg_struct, int field, msg_list_handle_t *value)
 663 {
 664         msg_error_t err = MSG_SUCCESS;
 665
 666         switch(msg_struct->type) {
 667         case MSG_STRUCT_MMS:
 668         {
 669                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
 670                 if (field == MSG_MMS_PAGE_LIST_HND)
 671                         *value = (msg_list_handle_t)mms_data->pagelist;
 672                 else if (field == MSG_MMS_REGION_LIST_HND)
 673                         *value = (msg_list_handle_t)mms_data->regionlist;
 674                 else if (field == MSG_MMS_ATTACH_LIST_HND)
 675                         *value = (msg_list_handle_t)mms_data->attachlist;
 676                 else if (field == MSG_MMS_TRANSITION_LIST_HND)
 677                         *value = (msg_list_handle_t)mms_data->transitionlist;
 678                 else if (field == MSG_MMS_META_LIST_HND)
 679                         *value = (msg_list_handle_t)mms_data->metalist;
 680                 else
 681                         err = MSG_ERR_INVALID_PARAMETER;
 682         }
 683         break;
 684         case MSG_STRUCT_MMS_PAGE:
 685         {
 686                 MMS_PAGE_S *mms_page_data = (MMS_PAGE_S *)msg_struct->data;
 687                 if (field == MSG_MMS_PAGE_MEDIA_LIST_HND)
 688                         *value = (msg_list_handle_t)mms_page_data->medialist;
 689                 else
 690                         err = MSG_ERR_INVALID_PARAMETER;
 691         }
 692         break;
 693         default :
 694                 err = MSG_ERR_INVALID_PARAMETER;
 695                 break;
 696         }
 697         return MSG_SUCCESS;
 698 }
 699 /*SET*/
 700 int msg_mms_set_int_value(msg_struct_s *msg_struct, int field, int value)
 701 {
 702         msg_error_t err = MSG_SUCCESS;
 703
 704         switch(msg_struct->type) {
 705         case MSG_STRUCT_MMS:
 706         {
 707                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
 708                 if (field == MSG_MMS_ROOTLAYOUT_WIDTH_INT)
 709                         mms_data->rootlayout.width.value = value;
 710                 else if (field == MSG_MMS_ROOTLAYOUT_HEIGHT_INT)
 711                         mms_data->rootlayout.height.value = value;
 712                 else if (field == MSG_MMS_ROOTLAYOUT_BGCOLOR_INT) {
 713                         mms_data->rootlayout.bBgColor = true;
 714                         mms_data->rootlayout.bgColor = value;
 715                 }
 716                 else
 717                         err = MSG_ERR_INVALID_PARAMETER;
 718         }
 719         break;
 720         case MSG_STRUCT_MMS_PAGE:
 721         {
 722                 MMS_PAGE_S *mms_page_data = (MMS_PAGE_S *)msg_struct->data;
 723                 if (field == MSG_MMS_PAGE_PAGE_DURATION_INT)
 724                         mms_page_data->nDur = value;
 725                 else if (field == MSG_MMS_PAGE_BEGIN_TIME_INT)
 726                         mms_page_data->nBegin = value;
 727                 else if (field == MSG_MMS_PAGE_END_TIME_INT)
 728                         mms_page_data->nEnd = value;
 729                 else if (field == MSG_MMS_PAGE_MIN_INT)
 730                         mms_page_data->nMin = value;
 731                 else if (field == MSG_MMS_PAGE_MAX_INT)
 732                         mms_page_data->nMax = value;
 733                 else if (field == MSG_MMS_PAGE_REPEAT_INT)
 734                         mms_page_data->nRepeat = value;
 735                 else
 736                         err = MSG_ERR_INVALID_PARAMETER;
 737         }
 738         break;
 739         case MSG_STRUCT_MMS_MEDIA:
 740         {
 741                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
 742                 if (field == MSG_MMS_MEDIA_TYPE_INT)
 743                         mms_media_data->mediatype = (MmsSmilMediaType)value;
 744                 else if (field == MSG_MMS_MEDIA_DRM_TYPE_INT)
 745                         mms_media_data->drmType = (MsgDrmType)value;
 746                 else
 747                         err = MSG_ERR_INVALID_PARAMETER;
 748         }
 749         break;
 750         case MSG_STRUCT_MMS_ATTACH:
 751         {
 752                 MMS_ATTACH_S *mms_attach_data = (MMS_ATTACH_S *)msg_struct->data;
 753                 if (field == MSG_MMS_ATTACH_MIME_TYPE_INT)
 754                         mms_attach_data->mediatype = (MimeType)value;
 755                 else if (field == MSG_MMS_ATTACH_FILESIZE_INT)
 756                         mms_attach_data->fileSize = value;
 757                 else if (field == MSG_MMS_ATTACH_DRM_TYPE_INT)
 758                         mms_attach_data->drmType = (MsgDrmType)value;
 759                 else
 760                         err = MSG_ERR_INVALID_PARAMETER;
 761         }
 762         break;
 763         case MSG_STRUCT_MMS_REGION:
 764         {
 765                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
 766                 if (field == MSG_MMS_REGION_LENGTH_LEFT_INT)
 767                         mms_region_data->nLeft.value = value;
 768                 else if (field == MSG_MMS_REGION_LENGTH_TOP_INT)
 769                         mms_region_data->nTop.value = value;
 770                 else if (field == MSG_MMS_REGION_LENGTH_WIDTH_INT)
 771                         mms_region_data->width.value = value;
 772                 else if (field == MSG_MMS_REGION_LENGTH_HEIGHT_INT)
 773                         mms_region_data->height.value = value;
 774                 else if (field == MSG_MMS_REGION_BGCOLOR_INT) {
 775                         mms_region_data->bBgColor = true;
 776                         mms_region_data->bgColor = value;
 777                 } else if (field == MSG_MMS_REGION_FIT_TYPE_INT)
 778                         mms_region_data->fit = (REGION_FIT_TYPE_T)value;
 779                 else
 780                         err = MSG_ERR_INVALID_PARAMETER;
 781         }
 782         break;
 783         case MSG_STRUCT_MMS_TRANSITION:
 784         {
 785                 MMS_SMIL_TRANSITION *mms_transition_data = (MMS_SMIL_TRANSITION *)msg_struct->data;
 786                 if (field == MSG_MMS_TRANSITION_TYPE_INT)
 787                         mms_transition_data->nType = (MmsSmilTransType)value;
 788                 else if (field == MSG_MMS_TRANSITION_SUBTYPE_INT)
 789                         mms_transition_data->nSubType = (MmsSmilTransSubType)value;
 790                 else if (field == MSG_MMS_TRANSITION_DURATION_INT)
 791                         mms_transition_data->nDur = value;
 792                 else
 793                         err = MSG_ERR_INVALID_PARAMETER;
 794         }
 795         break;
 796         case MSG_STRUCT_MMS_SMIL_TEXT:
 797         {
 798                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
 799                 if (field == MSG_MMS_SMIL_TEXT_REPEAT_INT)
 800                         mms_smil_text_data->nRepeat = value;
 801                 else if (field == MSG_MMS_SMIL_TEXT_BEGIN_INT)
 802                         mms_smil_text_data->nBegin = value;
 803                 else if (field == MSG_MMS_SMIL_TEXT_END_INT)
 804                         mms_smil_text_data->nEnd = value;
 805                 else if (field == MSG_MMS_SMIL_TEXT_DURTIME_INT)
 806                         mms_smil_text_data->nDurTime = value;
 807                 else if (field == MSG_MMS_SMIL_TEXT_BGCOLOR_INT)
 808                         mms_smil_text_data->nBgColor = value;
 809                 else if (field == MSG_MMS_SMIL_TEXT_DIRECTION_TYPE_INT)
 810                         mms_smil_text_data->nDirection = (MmsTextDirection)value;
 811                 else if (field == MSG_MMS_SMIL_TEXT_SIZE_INT)
 812                         mms_smil_text_data->nSize = value;
 813                 else if (field == MSG_MMS_SMIL_TEXT_COLOR_INT)
 814                         mms_smil_text_data->nColor = value;
 815                 else
 816                         err = MSG_ERR_INVALID_PARAMETER;
 817         }
 818         break;
 819         case MSG_STRUCT_MMS_SMIL_AVI:
 820         {
 821                 MmsSmilAVI *mms_smil_avi_data = (MmsSmilAVI *)msg_struct->data;
 822                 if (field == MSG_MMS_SMIL_AVI_REPEAT_INT)
 823                         mms_smil_avi_data->nRepeat = value;
 824                 else if (field == MSG_MMS_SMIL_AVI_BEGIN_INT)
 825                         mms_smil_avi_data->nBegin = value;
 826                 else if (field == MSG_MMS_SMIL_AVI_END_INT)
 827                         mms_smil_avi_data->nEnd = value;
 828                 else if (field == MSG_MMS_SMIL_AVI_DURTIME_INT)
 829                         mms_smil_avi_data->nDurTime = value;
 830                 else if (field == MSG_MMS_SMIL_AVI_BGCOLOR_INT)
 831                         mms_smil_avi_data->nBgColor = value;
 832                 else
 833                         err = MSG_ERR_INVALID_PARAMETER;
 834         }
 835         break;
 836         default :
 837                 err = MSG_ERR_INVALID_PARAMETER;
 838                 break;
 839         }
 840         return MSG_SUCCESS;
 841 }
 842
 843 int msg_mms_set_str_value(msg_struct_s *msg_struct, int field, char *value, int size)
 844 {
 845         msg_error_t err = MSG_SUCCESS;
 846
 847         switch(msg_struct->type) {
 848         case MSG_STRUCT_MMS_MEDIA:
 849         {
 850                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
 851                 if (field == MSG_MMS_MEDIA_SRC_STR)
 852                         strncpy(mms_media_data->szSrc, value, MSG_FILEPATH_LEN_MAX);
 853                 else if (field == MSG_MMS_MEDIA_FILENAME_STR) {
 854                         strncpy(mms_media_data->szFileName, value, MSG_FILEPATH_LEN_MAX);
 855                 } else if (field == MSG_MMS_MEDIA_FILEPATH_STR) {
 856                         char *filename = NULL;
 857                         if (value != NULL) {
 858                                 MSG_DEBUG("media file path = %s", value);
 859                                 strncpy(mms_media_data->szFilePath, value, MSG_FILEPATH_LEN_MAX);
 860                                 filename = strrchr(value, '/');
 861                                 if (filename != NULL) {
 862                                         strncpy(mms_media_data->szFileName, filename + 1, MSG_FILENAME_LEN_MAX);
 863                                         strncpy(mms_media_data->szContentID, filename + 1, MSG_MSG_ID_LEN);
 864                                 } else {
 865                                         strncpy(mms_media_data->szFileName, value + 1, MSG_FILENAME_LEN_MAX);
 866                                         strncpy(mms_media_data->szContentID, value + 1, MSG_MSG_ID_LEN);
 867                                 }
 868                         } else {
 869                                 MSG_DEBUG("media file path is NULL");
 870                                 err = MSG_ERR_INVALID_PARAMETER;
 871                         }
 872                 } else if (field == MSG_MMS_MEDIA_CONTENT_ID_STR)
 873                         __removeLessGreaterMark(value, mms_media_data->szContentID, MSG_MSG_ID_LEN);
 874                  else if (field == MSG_MMS_MEDIA_REGION_ID_STR)
 875                         strncpy(mms_media_data->regionId, value, MAX_SMIL_REGION_ID);
 876                 else if (field == MSG_MMS_MEDIA_ALTERNATIVE_STR)
 877                         strncpy(mms_media_data->szAlt, value, MAX_SMIL_ALT_LEN);
 878                 else if (field == MSG_MMS_MEDIA_DRM_FULLPATH_STR)
 879                         strncpy(mms_media_data->szDrm2FullPath, value, MSG_FILEPATH_LEN_MAX);
 880                 else
 881                         err = MSG_ERR_INVALID_PARAMETER;
 882         }
 883         break;
 884         case MSG_STRUCT_MMS_ATTACH:
 885         {
 886                 MMS_ATTACH_S *mms_attach_data = (MMS_ATTACH_S *)msg_struct->data;
 887                 if (field == MSG_MMS_ATTACH_FILENAME_STR)
 888                         strncpy(mms_attach_data->szFileName, value, MSG_FILENAME_LEN_MAX);
 889                 else if (field == MSG_MMS_ATTACH_FILEPATH_STR) {
 890                         char *filename = NULL;
 891                         char *filepath = value;
 892
 893                         if (filepath != NULL) {
 894                                 MSG_DEBUG("attach file path = %s", filepath);
 895                                 mms_attach_data->mediatype = MIME_UNKNOWN;
 896                                 mms_attach_data->fileSize = -1;
 897
 898                                 strncpy(mms_attach_data->szFilePath, filepath, MSG_FILEPATH_LEN_MAX);
 899
 900                                 filename = strrchr(filepath, '/');
 901                                 if (filename != NULL) {
 902                                         strncpy(mms_attach_data->szFileName, filename + 1, MSG_FILENAME_LEN_MAX);
 903                                 } else {
 904                                         strncpy(mms_attach_data->szFileName, filepath, MSG_FILENAME_LEN_MAX);
 905                                 }
 906
 907                         } else {
 908                                 MSG_DEBUG("attach file path is NULL");
 909                                 err = MSG_ERR_INVALID_PARAMETER;
 910                         }
 911                 } else if (field == MSG_MMS_ATTACH_DRM_FULLPATH_STR)
 912                         strncpy(mms_attach_data->szDrm2FullPath, value, MSG_FILEPATH_LEN_MAX);
 913                 else
 914                         err = MSG_ERR_INVALID_PARAMETER;
 915         }
 916         break;
 917         case MSG_STRUCT_MMS_REGION:
 918         {
 919                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
 920                 if (field == MSG_MMS_REGION_ID_STR)
 921                         strncpy(mms_region_data->szID, value, MAX_SMIL_REGION_ID);
 922                 else
 923                         err = MSG_ERR_INVALID_PARAMETER;
 924         }
 925         break;
 926         case MSG_STRUCT_MMS_TRANSITION:
 927         {
 928                 MMS_SMIL_TRANSITION *mms_transition_data = (MMS_SMIL_TRANSITION *)msg_struct->data;
 929                 if (field == MSG_MMS_TRANSITION_ID_STR)
 930                         strncpy(mms_transition_data->szID, value, MAX_SMIL_TRANSITION_ID);
 931                 else
 932                         err = MSG_ERR_INVALID_PARAMETER;
 933         }
 934         break;
 935         case MSG_STRUCT_MMS_META:
 936         {
 937                 MMS_SMIL_META *mms_meta_data = (MMS_SMIL_META *)msg_struct->data;
 938                 if (field == MSG_MMS_META_ID_STR)
 939                         strncpy(mms_meta_data->szID, value, MAX_SMIL_META_ID);
 940                 else if (field == MSG_MMS_META_NAME_STR)
 941                         strncpy(mms_meta_data->szName, value, MAX_SMIL_META_NAME);
 942                 else if (field == MSG_MMS_META_CONTENT_STR)
 943                         strncpy(mms_meta_data->szContent, value, MAX_SMIL_META_CONTENT);
 944                 else
 945                         err = MSG_ERR_INVALID_PARAMETER;
 946         }
 947         break;
 948         case MSG_STRUCT_MMS_SMIL_TEXT:
 949         {
 950                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
 951                 if (field == MSG_MMS_SMIL_TEXT_TRANSITION_IN_ID_STR)
 952                         strncpy(mms_smil_text_data->szTransInId, value, MAX_SMIL_TRANSIN_ID);
 953                 else if (field == MSG_MMS_SMIL_TEXT_TRANSITION_OUT_ID_STR)
 954                         strncpy(mms_smil_text_data->szTransOutId, value, MAX_SMIL_TRANSOUT_ID);
 955                 else
 956                         err = MSG_ERR_INVALID_PARAMETER;
 957         }
 958         break;
 959         case MSG_STRUCT_MMS_SMIL_AVI:
 960         {
 961                 MmsSmilAVI *mms_smil_avi_data = (MmsSmilAVI *)msg_struct->data;
 962                 if (field == MSG_MMS_SMIL_AVI_TRANSITION_IN_ID_STR)
 963                         strncpy(mms_smil_avi_data->szTransInId, value, MAX_SMIL_TRANSIN_ID);
 964                 else if (field == MSG_MMS_SMIL_AVI_TRANSITION_OUT_ID_STR)
 965                         strncpy(mms_smil_avi_data->szTransOutId, value, MAX_SMIL_TRANSOUT_ID);
 966                 else
 967                         err = MSG_ERR_INVALID_PARAMETER;
 968         }
 969         break;
 970         default :
 971                         err = MSG_ERR_INVALID_PARAMETER;
 972                 break;
 973         }
 974         return MSG_SUCCESS;
 975 }
 976
 977 int msg_mms_set_bool_value(msg_struct_s *msg_struct, int field, bool value)
 978 {
 979         msg_error_t err = MSG_SUCCESS;
 980
 981         switch(msg_struct->type) {
 982         case MSG_STRUCT_MMS:
 983         {
 984                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
 985                 if (field == MSG_MMS_ROOTLAYOUT_WIDTH_PERCENT_BOOL)
 986                         mms_data->rootlayout.width.bUnitPercent = value;
 987                 else if (field == MSG_MMS_ROOTLAYOUT_HEIGHT_PERCENT_BOOL)
 988                         mms_data->rootlayout.height.bUnitPercent = value;
 989                 else
 990                         err  = MSG_ERR_INVALID_PARAMETER;
 991         }
 992         break;
 993         case MSG_STRUCT_MMS_REGION:
 994         {
 995                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
 996                 if (field == MSG_MMS_REGION_LENGTH_LEFT_PERCENT_BOOL)
 997                         mms_region_data->nLeft.bUnitPercent = value;
 998                 else if (field == MSG_MMS_REGION_LENGTH_TOP_PERCENT_BOOL)
 999                         mms_region_data->nTop.bUnitPercent = value;
1000                 else if (field == MSG_MMS_REGION_LENGTH_WIDTH_PERCENT_BOOL)
1001                         mms_region_data->width.bUnitPercent = value;
1002                 else if (field == MSG_MMS_REGION_LENGTH_HEIGHT_PERCENT_BOOL)
1003                         mms_region_data->height.bUnitPercent = value;
1004                 else
1005                         err = MSG_ERR_INVALID_PARAMETER;
1006         }
1007         break;
1008         case MSG_STRUCT_MMS_SMIL_TEXT:
1009         {
1010                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
1011                 if (field == MSG_MMS_SMIL_TEXT_BOLD_BOOL)
1012                         mms_smil_text_data->bBold = value;
1013                 else if (field == MSG_MMS_SMIL_TEXT_UNDERLINE_BOOL)
1014                         mms_smil_text_data->bUnderLine = value;
1015                 else if (field == MSG_MMS_SMIL_TEXT_ITALIC_BOOL)
1016                         mms_smil_text_data->bItalic = value;
1017                 else if (field == MSG_MMS_SMIL_TEXT_REVERSE_BOOL)
1018                         mms_smil_text_data->bReverse = value;
1019                 else
1020                         err = MSG_ERR_INVALID_PARAMETER;
1021         }
1022         break;
1023         default :
1024                 err = MSG_ERR_INVALID_PARAMETER;
1025                 break;
1026         }
1027         return MSG_SUCCESS;
1028 }
1029
1030 int msg_mms_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
1031 {
1032         msg_error_t err = MSG_SUCCESS;
1033
1034         switch(msg_struct->type) {
1035         case MSG_STRUCT_MMS_MEDIA:
1036         {
1037                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
1038
1039                 if (field == MSG_MMS_MEDIA_SMIL_TEXT_HND)
1040                         memcpy(mms_media_data->pText->data, value->data, sizeof(MmsSmilText));
1041                 else if (field == MSG_MMS_MEDIA_SMIL_AVI_HND)
1042                         memcpy(mms_media_data->pAVI->data, value->data, sizeof(MmsSmilAVI));
1043                 else
1044                         err = MSG_ERR_INVALID_PARAMETER;
1045         }
1046         break;
1047         default :
1048                 err = MSG_ERR_INVALID_PARAMETER;
1049                 break;
1050         }
1051         return MSG_SUCCESS;
1052 }
1053
1054 int msg_mms_set_list_handle(msg_struct_s *msg_struct, int field, msg_list_handle_t value)
1055 {
1056         msg_error_t err = MSG_SUCCESS;
1057
1058         switch(msg_struct->type) {
1059         case MSG_STRUCT_MMS:
1060         {
1061                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
1062                 if (field == MSG_MMS_PAGE_LIST_HND)
1063                         mms_data->pagelist = (GList *)value;
1064                 else if (field == MSG_MMS_REGION_LIST_HND)
1065                         mms_data->regionlist = (GList *)value;
1066                 else if (field == MSG_MMS_ATTACH_LIST_HND)
1067                         mms_data->attachlist = (GList *)value;
1068                 else if (field == MSG_MMS_TRANSITION_LIST_HND)
1069                         mms_data->transitionlist = (GList *)value;
1070                 else if (field == MSG_MMS_META_LIST_HND)
1071                         mms_data->metalist = (GList *)value;
1072                 else
1073                         err = MSG_ERR_INVALID_PARAMETER;
1074         }
1075         break;
1076         case MSG_STRUCT_MMS_PAGE:
1077         {
1078                 MMS_PAGE_S *mms_page_data = (MMS_PAGE_S *)msg_struct->data;
1079                 if (field == MSG_MMS_PAGE_MEDIA_LIST_HND)
1080                         mms_page_data->medialist = (GList *)value;
1081                 else
1082                         err = MSG_ERR_INVALID_PARAMETER;
1083         }
1084         break;
1085         default :
1086                 err = MSG_ERR_INVALID_PARAMETER;
1087                 break;
1088         }
1089         return MSG_SUCCESS;
1090 }
1091
1092 EXPORT_API int msg_mms_add_item(msg_struct_t msg_struct_handle, int field, msg_struct_t *item)
1093 {
1094         msg_error_t err = MSG_SUCCESS;
1095         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
1096
1097         msg_struct_s *msg_struct_item = NULL;
1098         switch(msg_struct->type) {
1099         case MSG_STRUCT_MMS:
1100         {
1101
1102                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
1103
1104                 if (field == MSG_STRUCT_MMS_PAGE) {
1105                         msg_struct_item = msg_mms_create_struct(field);
1106                         mms_data->pagelist = g_list_append(mms_data->pagelist, msg_struct_item);
1107                         *item = (msg_struct_t)msg_struct_item;
1108                 } else if (field == MSG_STRUCT_MMS_REGION) {
1109                         msg_struct_item = msg_mms_create_struct(field);
1110                         mms_data->regionlist = g_list_append(mms_data->regionlist, msg_struct_item);
1111                         *item = (msg_struct_t)msg_struct_item;
1112                 } else if (field == MSG_STRUCT_MMS_ATTACH) {
1113                         msg_struct_item = msg_mms_create_struct(field);
1114                         mms_data->attachlist = g_list_append(mms_data->attachlist, msg_struct_item);
1115                         *item = (msg_struct_t)msg_struct_item;
1116                 } else if (field == MSG_STRUCT_MMS_TRANSITION) {
1117                         msg_struct_item = msg_mms_create_struct(field);
1118                         mms_data->transitionlist = g_list_append(mms_data->transitionlist, msg_struct_item);
1119                         *item = (msg_struct_t)msg_struct_item;
1120                 } else if (field == MSG_STRUCT_MMS_META) {
1121                         msg_struct_item = msg_mms_create_struct(field);
1122                         mms_data->metalist = g_list_append(mms_data->metalist, msg_struct_item);
1123                         *item = (msg_struct_t)msg_struct_item;
1124                 } else {
1125                         err = MSG_ERR_INVALID_PARAMETER;
1126                 }
1127         }
1128         break;
1129         case MSG_STRUCT_MMS_PAGE:
1130         {
1131
1132                 MMS_PAGE_S *mms_page_data = (MMS_PAGE_S *)msg_struct->data;
1133
1134                 if (field == MSG_STRUCT_MMS_MEDIA) {
1135                         msg_struct_item = msg_mms_create_struct(field);
1136                         mms_page_data->medialist = g_list_append(mms_page_data->medialist, msg_struct_item);
1137                         *item = (msg_struct_t)msg_struct_item;
1138                 } else {
1139                         err = MSG_ERR_INVALID_PARAMETER;
1140                 }
1141         }
1142         break;
1143         default :
1144                 err = MSG_ERR_INVALID_PARAMETER;
1145                 break;
1146         }
1147
1148         return err;
1149 }
1150
1151 void convert_to_media_data(const msg_struct_s *pSrc, MMS_MEDIA_S *pDest)
1152 {
1153         const MMS_MEDIA_HIDDEN_S *src_media = (MMS_MEDIA_HIDDEN_S *)pSrc->data;
1154         MMS_MEDIA_S *dst_media = pDest;
1155
1156         dst_media->mediatype = src_media->mediatype;
1157         memcpy(dst_media->szSrc, src_media->szSrc, MSG_FILEPATH_LEN_MAX);
1158         memcpy(dst_media->szFileName, src_media->szFileName, MSG_FILEPATH_LEN_MAX);
1159         memcpy(dst_media->szFilePath, src_media->szFilePath, MSG_FILEPATH_LEN_MAX);
1160         memcpy(dst_media->szContentID, src_media->szContentID, MSG_MSG_ID_LEN);
1161         memcpy(dst_media->regionId, src_media->regionId, MAX_SMIL_REGION_ID);
1162         memcpy(dst_media->szAlt, src_media->szAlt, MAX_SMIL_ALT_LEN);
1163
1164         memcpy(dst_media->szDrm2FullPath, src_media->szDrm2FullPath, MSG_FILEPATH_LEN_MAX);
1165         dst_media->drmType = src_media->drmType;
1166
1167         if (src_media->mediatype == MMS_SMIL_MEDIA_TEXT) {
1168                 msg_struct_s *smil_struct = (msg_struct_s *)src_media->pText;
1169                 MmsSmilText *smiltext = (MmsSmilText *)smil_struct->data;
1170                 memcpy(&dst_media->sMedia.sText, smiltext, sizeof(MmsSmilText));
1171         } else {
1172                 msg_struct_s *smil_struct = (msg_struct_s *)src_media->pAVI;
1173                 MmsSmilAVI *smilavi = (MmsSmilAVI *)smil_struct->data;
1174                 memcpy(&dst_media->sMedia.sAVI, smilavi, sizeof(MmsSmilAVI));
1175         }
1176 }
1177
1178 void convert_from_media_data(const MMS_MEDIA_S *pSrc, msg_struct_s *pDest)
1179 {
1180         const MMS_MEDIA_S *src_media = pSrc;
1181         MMS_MEDIA_HIDDEN_S *dst_media = (MMS_MEDIA_HIDDEN_S *)pDest->data;
1182
1183         dst_media->mediatype = src_media->mediatype;
1184         memcpy(dst_media->szSrc, src_media->szSrc, MSG_FILEPATH_LEN_MAX);
1185         memcpy(dst_media->szFileName, src_media->szFileName, MSG_FILEPATH_LEN_MAX);
1186         memcpy(dst_media->szFilePath, src_media->szFilePath, MSG_FILEPATH_LEN_MAX);
1187         memcpy(dst_media->szContentID, src_media->szContentID, MSG_MSG_ID_LEN);
1188         memcpy(dst_media->regionId, src_media->regionId, MAX_SMIL_REGION_ID);
1189         memcpy(dst_media->szAlt, src_media->szAlt, MAX_SMIL_ALT_LEN);
1190
1191         memcpy(dst_media->szDrm2FullPath, src_media->szDrm2FullPath, MSG_FILEPATH_LEN_MAX);
1192         dst_media->drmType = src_media->drmType;
1193
1194         if (src_media->mediatype == MMS_SMIL_MEDIA_TEXT) {
1195                 msg_struct_s *dst_smil_struct = (msg_struct_s *)dst_media->pText;
1196                 MmsSmilText *dst_smiltext = (MmsSmilText *)dst_smil_struct->data;
1197                 memcpy(dst_smiltext, &src_media->sMedia.sText, sizeof(MmsSmilText));
1198         } else {
1199                 msg_struct_s *dst_smil_struct = (msg_struct_s *)dst_media->pAVI;
1200                 MmsSmilAVI *dst_smilavi = (MmsSmilAVI *)dst_smil_struct->data;
1201                 memcpy(dst_smilavi, &src_media->sMedia.sAVI, sizeof(MmsSmilAVI));
1202         }
1203 }
1204
1205 void convert_to_mmsdata(const msg_struct_s *pSrc, MMS_MESSAGE_DATA_S *pDest)
1206 {
1207         int i, j;
1208         MMS_DATA_HIDDEN_S *pSrcMms = (MMS_DATA_HIDDEN_S *)pSrc->data;
1209
1210         pDest->pageCnt = g_list_length(pSrcMms->pagelist);
1211
1212         for (i = 0; i < pDest->pageCnt; i++) {
1213                 MMS_PAGE_S *page = (MMS_PAGE_S *)calloc(1, sizeof(MMS_PAGE_S));
1214                 MMS_PAGE_S *src_page = (MMS_PAGE_S *)get_msg_struct_data((msg_struct_s *)g_list_nth_data(pSrcMms->pagelist, i));
1215                 page->mediaCnt = g_list_length(src_page->medialist);
1216
1217                 for (j = 0; j < page->mediaCnt; j++)
1218                 {
1219                         MMS_MEDIA_S *dst_media = (MMS_MEDIA_S *)calloc(1, sizeof(MMS_MEDIA_S));
1220                         msg_struct_s *src_media_s = (msg_struct_s *)g_list_nth_data(src_page->medialist, j);
1221
1222                         convert_to_media_data(src_media_s, dst_media);
1223
1224                         page->medialist = g_list_append(page->medialist, dst_media);
1225                 }
1226
1227                 page->nDur = src_page->nDur;
1228                 page->nBegin = src_page->nBegin;
1229                 page->nEnd = src_page->nEnd;
1230                 page->nMin = src_page->nMin;
1231                 page->nMax = src_page->nMax;
1232                 page->nRepeat = src_page->nRepeat;
1233
1234                 pDest->pagelist = g_list_append(pDest->pagelist, page);
1235         }
1236
1237         pDest->regionCnt = g_list_length(pSrcMms->regionlist);
1238
1239         for (i = 0; i < pDest->regionCnt; i++) {
1240                 MMS_SMIL_REGION *region = (MMS_SMIL_REGION *)calloc(1, sizeof(MMS_SMIL_REGION));
1241                 MMS_SMIL_REGION *src_region = (MMS_SMIL_REGION *)get_msg_struct_data((msg_struct_s *)g_list_nth_data(pSrcMms->regionlist, i));
1242                 memcpy(region, src_region, sizeof(MMS_SMIL_REGION));
1243                 pDest->regionlist = g_list_append(pDest->regionlist, region);
1244         }
1245
1246         pDest->attachCnt = g_list_length(pSrcMms->attachlist);
1247
1248         for (i = 0; i < pDest->attachCnt; i++) {
1249                 MMS_ATTACH_S *attach = (MMS_ATTACH_S *)calloc(1, sizeof(MMS_ATTACH_S));
1250                 MMS_ATTACH_S *src_attach = (MMS_ATTACH_S *)get_msg_struct_data((msg_struct_s *)g_list_nth_data(pSrcMms->attachlist, i));
1251                 memcpy(attach, src_attach, sizeof(MMS_ATTACH_S));
1252                 pDest->attachlist = g_list_append(pDest->attachlist, attach);
1253         }
1254
1255         pDest->transitionCnt = g_list_length(pSrcMms->transitionlist);
1256
1257         for (i = 0; i < pDest->transitionCnt; i++) {
1258                 MMS_SMIL_TRANSITION *transition = (MMS_SMIL_TRANSITION *)calloc(1, sizeof(MMS_SMIL_TRANSITION));
1259                 MMS_SMIL_TRANSITION *src_transition = (MMS_SMIL_TRANSITION *)get_msg_struct_data((msg_struct_s *)g_list_nth_data(pSrcMms->transitionlist, i));
1260                 memcpy(transition, src_transition, sizeof(MMS_SMIL_TRANSITION));
1261                 pDest->transitionlist = g_list_append(pDest->transitionlist, transition);
1262         }
1263
1264         pDest->metaCnt = g_list_length(pSrcMms->metalist);
1265
1266         for (i = 0; i < pDest->metaCnt; i++) {
1267                 MMS_SMIL_META *meta = (MMS_SMIL_META *)calloc(1, sizeof(MMS_SMIL_META));
1268                 MMS_SMIL_META *src_meta = (MMS_SMIL_META *)get_msg_struct_data((msg_struct_s *)g_list_nth_data(pSrcMms->metalist, i));
1269                 memcpy(meta, src_meta, sizeof(MMS_SMIL_META));
1270                 pDest->metalist = g_list_append(pDest->metalist, meta);
1271         }
1272
1273         memcpy(&pDest->rootlayout, &pSrcMms->rootlayout, sizeof(MMS_SMIL_ROOTLAYOUT));
1274
1275         memcpy(&pDest->msgAppId, &pSrcMms->msgAppId, sizeof(MMS_APPID_INFO_S));
1276 }
1277
1278 void convert_from_mmsdata(const MMS_MESSAGE_DATA_S *pSrc, msg_struct_s *pDest)
1279 {
1280         int i, j;
1281         MMS_DATA_HIDDEN_S *pDestMms = (MMS_DATA_HIDDEN_S *)pDest->data;
1282
1283         for (i = 0; i < pSrc->pageCnt; i++) {
1284                 msg_struct_s *page_struct = msg_mms_create_struct(MSG_STRUCT_MMS_PAGE);
1285                 MMS_PAGE_S *page = (MMS_PAGE_S *)page_struct->data;
1286
1287                 MMS_PAGE_S *src_page = (MMS_PAGE_S *)g_list_nth_data(pSrc->pagelist, i);
1288                 page->mediaCnt = g_list_length(src_page->medialist);
1289
1290                 for (j = 0; j < page->mediaCnt; j++)
1291                 {
1292                         msg_struct_s *dst_media_s = msg_mms_create_struct(MSG_STRUCT_MMS_MEDIA);
1293
1294                         MMS_MEDIA_S *src_media = (MMS_MEDIA_S *)g_list_nth_data(src_page->medialist, j);
1295
1296                         convert_from_media_data(src_media, dst_media_s);
1297
1298                         page->medialist = g_list_append(page->medialist, dst_media_s);
1299                 }
1300
1301                 page->nDur = src_page->nDur;
1302                 page->nBegin = src_page->nBegin;
1303                 page->nEnd = src_page->nEnd;
1304                 page->nMin = src_page->nMin;
1305                 page->nMax = src_page->nMax;
1306                 page->nRepeat = src_page->nRepeat;
1307
1308                 pDestMms->pagelist = g_list_append(pDestMms->pagelist, page_struct);
1309         }
1310
1311         for (i = 0; i < pSrc->regionCnt; i++) {
1312                 msg_struct_s *region_struct = msg_mms_create_struct(MSG_STRUCT_MMS_REGION);
1313                 MMS_SMIL_REGION *region = (MMS_SMIL_REGION *)region_struct->data;
1314                 MMS_SMIL_REGION *src_region = (MMS_SMIL_REGION *)g_list_nth_data(pSrc->regionlist, i);
1315                 memcpy(region, src_region, sizeof(MMS_SMIL_REGION));
1316                 pDestMms->regionlist = g_list_append(pDestMms->regionlist, region_struct);
1317         }
1318
1319         for (i = 0; i < pSrc->attachCnt; i++) {
1320                 msg_struct_s *attach_struct = msg_mms_create_struct(MSG_STRUCT_MMS_ATTACH);
1321                 MMS_ATTACH_S *attach = (MMS_ATTACH_S *)attach_struct->data;
1322                 MMS_ATTACH_S *src_attach = (MMS_ATTACH_S *)g_list_nth_data(pSrc->attachlist, i);
1323                 memcpy(attach, src_attach, sizeof(MMS_ATTACH_S));
1324                 pDestMms->attachlist = g_list_append(pDestMms->attachlist, attach_struct);
1325         }
1326
1327         for (i = 0; i < pSrc->transitionCnt; i++) {
1328                 msg_struct_s *transition_struct = msg_mms_create_struct(MSG_STRUCT_MMS_TRANSITION);
1329                 MMS_SMIL_TRANSITION *transition = (MMS_SMIL_TRANSITION *)transition_struct->data;
1330                 MMS_SMIL_TRANSITION *src_transition = (MMS_SMIL_TRANSITION *)g_list_nth_data(pSrc->transitionlist, i);
1331                 memcpy(transition, src_transition, sizeof(MMS_SMIL_TRANSITION));
1332                 pDestMms->transitionlist = g_list_append(pDestMms->transitionlist, transition_struct);
1333         }
1334
1335         for (i = 0; i < pSrc->metaCnt; i++) {
1336                 msg_struct_s *meta_struct = msg_mms_create_struct(MSG_STRUCT_MMS_META);
1337                 MMS_SMIL_META *meta = (MMS_SMIL_META *)meta_struct->data;
1338                 MMS_SMIL_META *src_meta = (MMS_SMIL_META *)g_list_nth_data(pSrc->metalist, i);
1339
1340                 memcpy(meta, src_meta, sizeof(MMS_SMIL_META));
1341                 pDestMms->metalist = g_list_append(pDestMms->metalist, meta_struct);
1342         }
1343
1344         memcpy(&pDestMms->rootlayout, &pSrc->rootlayout, sizeof(MMS_SMIL_ROOTLAYOUT));
1345
1346         memcpy(&pDestMms->msgAppId, &pSrc->msgAppId, sizeof(MMS_APPID_INFO_S));
1347 }