mapi/msg_mms.cpp

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