TelegramTizen/src/tg_messaging_view.c

   1 /*
   2     This file is part of Telegram application for tizen
   3
   4     This library is free software; you can redistribute it and/or
   5     modify it under the terms of the GNU Lesser General Public
   6     License as published by the Free Software Foundation; either
   7     version 2.1 of the License, or (at your option) any later version.
   8
   9     This library is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12     Lesser General Public License for more details.
  13
  14     You should have received a copy of the GNU Lesser General Public
  15     License along with this library; if not, write to the Free Software
  16     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18
  19 #include "tg_messaging_view.h"
  20 #include "tg_db_wrapper.h"
  21 #include "server_requests.h"
  22 #include <attach_panel.h>
  23 #include <mime_type.h>
  24 #include <Elementary.h>
  25 #include "tg_user_info_view.h"
  26 #include "tg_chat_info_view.h"
  27 #include "tg_audio_player.h"
  28 #include <metadata_extractor.h>
  29 #include "tg_search_peer_view.h"
  30
  31 typedef struct buddies_name_and_id{
  32         char *name;
  33         int id;
  34 }buddies_info;
  35
  36 static int scroller_show_bottom_edge(Evas_Object *scroller)
  37 {
  38         if (!scroller) {
  39                 LOGE("Cannot get the scroller");
  40                 return 0;
  41         }
  42         Evas_Object *box_layout = NULL;
  43         Evas_Object *box = NULL;
  44         Eina_List *list = NULL;
  45
  46         box_layout = elm_object_content_get(scroller);
  47         if (!box_layout) {
  48                 LOGE("Fail to get the box into scroller");
  49                 return 0;
  50         }
  51         list = elm_box_children_get(box_layout);
  52         if (!list) {
  53                 LOGE("Fail to get the list into box");
  54                 return 0;
  55         }
  56
  57         box = eina_list_nth(list, 0);
  58         if (!box) {
  59                 LOGE("Fail to get the box into box layout");
  60                 return 0;
  61         }
  62
  63         int h;
  64         evas_object_geometry_get(box, NULL, NULL, NULL, &h);
  65         elm_scroller_region_show(scroller, 0, h, 720, 1280);
  66
  67         eina_list_free(list);
  68
  69         return 1;
  70 }
  71
  72 static int scroller_previous_region_get(Evas_Object *scroller)
  73 {
  74         if (!scroller) {
  75                 LOGE("Cannot get the scroller");
  76                 return 0;
  77         }
  78         Evas_Object *box_layout = NULL;
  79         Evas_Object *box = NULL;
  80         Eina_List *list = NULL;
  81
  82         box_layout = elm_object_content_get(scroller);
  83         if (!box_layout) {
  84                 LOGE("Fail to get the box into scroller");
  85                 return 0;
  86         }
  87         list = elm_box_children_get(box_layout);
  88         if (!list) {
  89                 LOGE("Fail to get the list into box");
  90                 return 0;
  91         }
  92
  93         box = eina_list_nth(list, 0);
  94         if (!box) {
  95                 LOGE("Fail to get the box into box layout");
  96                 return 0;
  97         }
  98
  99         int h;
 100         evas_object_geometry_get(box, NULL, NULL, NULL, &h);
 101
 102         eina_list_free(list);
 103
 104         return h;
 105 }
 106
 107 static int scroller_show_previous_region(Evas_Object *scroller)
 108 {
 109         if (!scroller) {
 110                 LOGE("Cannot get the scroller");
 111                 return 0;
 112         }
 113         Evas_Object *box_layout = NULL;
 114         Evas_Object *box = NULL;
 115         Eina_List *list = NULL;
 116
 117         box_layout = elm_object_content_get(scroller);
 118         if (!box_layout) {
 119                 LOGE("Fail to get the box into scroller");
 120                 return 0;
 121         }
 122         list = elm_box_children_get(box_layout);
 123         if (!list) {
 124                 LOGE("Fail to get the list into box");
 125                 return 0;
 126         }
 127
 128         box = eina_list_nth(list, 0);
 129         if (!box) {
 130                 LOGE("Fail to get the box into box layout");
 131                 return 0;
 132         }
 133
 134         int h,prev_h;
 135         prev_h = (int)evas_object_data_get(scroller, "previous_h");
 136         evas_object_geometry_get(box, NULL, NULL, NULL, &h);
 137         elm_scroller_region_show(scroller, 0, (h-prev_h), 720, 1280);
 138
 139         eina_list_free(list);
 140
 141         return 1;
 142 }
 143
 144 static void scroller_push_item(Evas_Object *scroller, Evas_Object *item, int prepand)
 145 {
 146         Evas_Object *box_layout = NULL;
 147         Evas_Object *box = NULL;
 148         Eina_List *list = NULL;
 149
 150         box_layout = elm_object_content_get(scroller);
 151         if (!box_layout) {
 152                 LOGE("Fail to get the box into scroller");
 153                 return;
 154         }
 155
 156         list = elm_box_children_get(box_layout);
 157         if (!list) {
 158                 LOGE("Fail to get the list into box");
 159                 return;
 160         }
 161
 162         box = eina_list_nth(list, 0);
 163         if (!box) {
 164                 LOGE("Fail to get the box into box layout");
 165                 return;
 166         }
 167
 168         eina_list_free(list);
 169
 170         if (!prepand) {
 171                 elm_box_pack_end(box, item);
 172
 173         } else {
 174                 elm_box_pack_start(box, item);
 175                 //elm_box_recalculate(box);
 176         }
 177
 178         return;
 179 }
 180
 181 /************************ Menu Handler ********************/
 182
 183 void on_messaging_menu_option_selected_cb(void *data, Evas_Object *obj, void *event_info)
 184 {
 185         appdata_s *ad = data;
 186         Elm_Object_Item *it = event_info;
 187         elm_genlist_item_selected_set(it, EINA_FALSE);
 188         int id = (int)elm_object_item_data_get(it);
 189
 190
 191         peer_with_pic_s  *sel_item = ad->peer_in_cahtting_data;
 192         tg_peer_info_s *user_data = sel_item->use_data;
 193
 194         if (!sel_item || !user_data) {
 195                 show_toast(ad, "There are no messages to delete.");
 196                 if (ad->msg_popup) {
 197                         evas_object_del(ad->msg_popup);
 198                         ad->msg_popup = NULL;
 199                 }
 200                 return;
 201         }
 202
 203
 204         if (get_buddy_unknown_status(user_data->peer_id) && user_data->peer_type == TGL_PEER_USER) {
 205
 206                 if (id == 0) {
 207                         ad->is_loading_from_msg_view = EINA_TRUE;
 208                         on_create_new_contact(ad);
 209                 } else if (id == 1) {
 210
 211                         // mark all the massages for deletion.
 212                         char* tablename = get_table_name_from_number(user_data->peer_id);
 213                         mark_all_records_for_deletion(tablename);
 214                         // delete date messages
 215                         delete_date_messages_from_table(tablename);
 216                         free(tablename);
 217                         // clear screen
 218                         // clear all messages
 219                         Evas_Object *scroller = evas_object_data_get(ad->nf, "chat_list");
 220
 221
 222                         Evas_Object *box_layout = NULL;
 223                         Evas_Object *box = NULL;
 224                         Eina_List *list = NULL;
 225
 226                         box_layout = elm_object_content_get(scroller);
 227                         if (!box_layout) {
 228                                 LOGE("Fail to get the box into scroller");
 229                                 return;
 230                         }
 231
 232                         list = elm_box_children_get(box_layout);
 233                         if (!list) {
 234                                 LOGE("Fail to get the list into box");
 235                                 return;
 236                         }
 237
 238                         box = eina_list_nth(list, 0);
 239                         if (!box) {
 240                                 LOGE("Fail to get the box into box layout");
 241                                 return;
 242                         }
 243
 244                         eina_list_free(list);
 245                         elm_box_clear(box);
 246                         elm_box_recalculate(box);
 247
 248
 249                         // send request to server
 250                         send_delete_group_chat_request(ad, ad->service_client, user_data->peer_id);
 251
 252                         if (ad->main_item_in_cahtting_data) {
 253                                 tg_main_list_item_s* old_item = ad->main_item_in_cahtting_data;
 254                                 if (old_item->last_message) {
 255                                         free(old_item->last_message);
 256                                         old_item->last_message = NULL;
 257                                 }
 258                                 old_item->last_message = strdup("");
 259                         }
 260
 261                         Evas_Object *nomsg_layout = evas_object_data_get(ad->nf, "chat_list_no_msg_text");
 262                         if (nomsg_layout) {
 263                                 elm_object_signal_emit(nomsg_layout, "show", "message");
 264                         }
 265
 266                 } else {
 267                         char* tablename = get_table_name_from_number(user_data->peer_id);
 268                         delete_all_records(tablename);
 269                         free(tablename);
 270
 271                         // clear all messages
 272                         Evas_Object *genlist = evas_object_data_get(ad->nf, "chat_list");
 273                         elm_genlist_clear(genlist);
 274
 275                         // remove main item from main list
 276                         if (ad->main_item_in_cahtting_data) {
 277                                 tg_main_list_item_s* old_item = ad->main_item_in_cahtting_data;
 278                                 if (old_item->peer_print_name) {
 279                                         free(old_item->peer_print_name);
 280                                         old_item->peer_print_name = NULL;
 281                                 }
 282                                 if (old_item->last_message) {
 283                                         free(old_item->last_message);
 284                                         old_item->last_message = NULL;
 285                                 }
 286                                 if (old_item->profile_pic_path) {
 287                                         free(old_item->profile_pic_path);
 288                                         old_item->profile_pic_path = NULL;
 289                                 }
 290                                 old_item->date_lbl = NULL;
 291                                 old_item->msg_status_lbl = NULL;
 292                                 old_item->main_item_layout = NULL;
 293                                 old_item->profile_pic = NULL;
 294                                 old_item->profile_pic_path = NULL;
 295                                 old_item->status_lbl = NULL;
 296                                 old_item->user_name_lbl = NULL;
 297                                 ad->main_list = eina_list_remove(ad->main_list,  ad->main_item_in_cahtting_data);
 298
 299                                 ad->main_item_in_cahtting_data = NULL;
 300                         }
 301
 302                         ad->is_last_msg_changed = EINA_FALSE;
 303
 304
 305                         app_nf_back_cb(ad, NULL, NULL);
 306                 }
 307                 if (ad->msg_popup) {
 308                         evas_object_del(ad->msg_popup);
 309                         ad->msg_popup = NULL;
 310                 }
 311                 return;
 312         }
 313
 314         if (user_data->peer_type == TGL_PEER_USER) {
 315                 if (id == 0) {
 316                         launch_user_info_screen(ad, user_data->peer_id);
 317                 } else if (id == 1) {
 318                         // mark all the massages for deletion.
 319                         char* tablename = get_table_name_from_number(user_data->peer_id);
 320                         mark_all_records_for_deletion(tablename);
 321                         // delete date messages
 322                         delete_date_messages_from_table(tablename);
 323                         free(tablename);
 324                         // clear screen
 325                         // clear all messages
 326                         Evas_Object *scroller = evas_object_data_get(ad->nf, "chat_list");
 327
 328
 329                         Evas_Object *box_layout = NULL;
 330                         Evas_Object *box = NULL;
 331                         Eina_List *list = NULL;
 332
 333                         box_layout = elm_object_content_get(scroller);
 334                         if (!box_layout) {
 335                                 LOGE("Fail to get the box into scroller");
 336                                 return;
 337                         }
 338
 339                         list = elm_box_children_get(box_layout);
 340                         if (!list) {
 341                                 LOGE("Fail to get the list into box");
 342                                 return;
 343                         }
 344
 345                         box = eina_list_nth(list, 0);
 346                         if (!box) {
 347                                 LOGE("Fail to get the box into box layout");
 348                                 return;
 349                         }
 350
 351                         eina_list_free(list);
 352                         elm_box_clear(box);
 353                         elm_box_recalculate(box);
 354
 355                         // send request to server
 356                         send_delete_all_messages_request(ad, ad->service_client, user_data->peer_id, user_data->peer_type);
 357
 358                         Evas_Object *nomsg_layout = evas_object_data_get(ad->nf, "chat_list_no_msg_text");
 359                         if (nomsg_layout) {
 360                                 elm_object_signal_emit(nomsg_layout, "show", "message");
 361                         }
 362                 }  else if (id == 2) {
 363                         show_loading_popup(ad);
 364                         char* tablename = get_table_name_from_number(user_data->peer_id);
 365                         delete_all_records(tablename);
 366                         free(tablename);
 367
 368                         elm_naviframe_item_pop(ad->nf);
 369                         load_registered_user_data(ad);
 370                         load_buddy_list_data(ad);
 371                         load_unknown_buddy_list_data(ad);
 372                         load_peer_data(ad);
 373                         load_main_list_data(ad);
 374                         ecore_timer_add(1, on_load_main_view_requested, ad);
 375                 }
 376         } else if (user_data->peer_type == TGL_PEER_CHAT) {
 377                 if (id == 0) {
 378                         // mark all the massages for deletion.
 379                         char* tablename = get_table_name_from_number(user_data->peer_id);
 380                         mark_all_records_for_deletion(tablename);
 381                         // delete date messages
 382                         delete_date_messages_from_table(tablename);
 383                         free(tablename);
 384                         // clear screen
 385                         // clear all messages
 386                         Evas_Object *scroller = evas_object_data_get(ad->nf, "chat_list");
 387
 388
 389                         Evas_Object *box_layout = NULL;
 390                         Evas_Object *box = NULL;
 391                         Eina_List *list = NULL;
 392
 393                         box_layout = elm_object_content_get(scroller);
 394                         if (!box_layout) {
 395                                 LOGE("Fail to get the box into scroller");
 396                                 return;
 397                         }
 398
 399                         list = elm_box_children_get(box_layout);
 400                         if (!list) {
 401                                 LOGE("Fail to get the list into box");
 402                                 return;
 403                         }
 404
 405                         box = eina_list_nth(list, 0);
 406                         if (!box) {
 407                                 LOGE("Fail to get the box into box layout");
 408                                 return;
 409                         }
 410
 411                         eina_list_free(list);
 412                         elm_box_clear(box);
 413                         elm_box_recalculate(box);
 414
 415                         send_delete_all_messages_request(ad, ad->service_client, user_data->peer_id, user_data->peer_type);
 416
 417                         Evas_Object *nomsg_layout = evas_object_data_get(ad->nf, "chat_list_no_msg_text");
 418                         if (nomsg_layout) {
 419                                 elm_object_signal_emit(nomsg_layout, "show", "message");
 420                         }
 421
 422                 } else if (id == 1) {
 423                         //send group chat delete request
 424                         show_loading_popup(ad);
 425                         send_delete_group_chat_request(ad, ad->service_client, user_data->peer_id);
 426                 }
 427         }
 428
 429         if (ad->msg_popup) {
 430                 evas_object_del(ad->msg_popup);
 431                 ad->msg_popup = NULL;
 432         }
 433         return;
 434 }
 435
 436
 437 char* on_messaging_menu_group_text_get_cb(void *data, Evas_Object *obj, const char *part)
 438 {
 439         int id = (int) data;
 440         if (id == 0) {
 441                 return strdup(i18n_get_text("IDS_TGRAM_OPT_CLEAR_HISTORY_ABB3"));
 442         } else {
 443                 return strdup(i18n_get_text("IDS_TGRAM_OPT_DELETE"));
 444         }
 445 }
 446
 447 char* on_messaging_menu_text_get_cb(void *data, Evas_Object *obj, const char *part)
 448 {
 449         int id = (int) data;
 450         appdata_s *ad = evas_object_data_get(obj, "app_data");
 451         peer_with_pic_s  *sel_item = ad->peer_in_cahtting_data;
 452         tg_peer_info_s *user_data = sel_item->use_data;
 453         if ((user_data->peer_type == TGL_PEER_USER) && get_buddy_unknown_status(user_data->peer_id)) {
 454             if (id == 0) {
 455                 return strdup(i18n_get_text("IDS_TGRAM_OPT_ADD_TO_CONTACTS_ABB2"));
 456             } else if (id == 1) {
 457                 return strdup(i18n_get_text("IDS_TGRAM_OPT_CLEAR_HISTORY_ABB3"));
 458                 } else {
 459                         return strdup(i18n_get_text("IDS_TGRAM_OPT_DELETE"));
 460                 }
 461         } else {
 462                 if (id == 0) {
 463                         return strdup(i18n_get_text("IDS_TGRAM_OPT_VIEW_PROFILE_ABB"));
 464                 } else if (id == 1) {
 465                         return strdup(i18n_get_text("IDS_TGRAM_OPT_CLEAR_HISTORY_ABB3"));
 466                 } else {
 467                         return strdup(i18n_get_text("IDS_TGRAM_OPT_DELETE"));
 468                 }
 469         }
 470 }
 471
 472 void on_msg_popup_back_cb(void *data, Evas_Object *obj, void *event_info)
 473 {
 474         appdata_s *ad = data;
 475         if (ad->msg_popup) {
 476                 evas_object_del(ad->msg_popup);
 477                 ad->msg_popup = NULL;
 478         }
 479 }
 480
 481 void on_messaging_menu_button_clicked(void *data, Evas_Object *obj, void *event_info)
 482 {
 483         appdata_s *ad = data;
 484         if (ad->msg_popup || ad->current_app_state != TG_CHAT_MESSAGING_VIEW_STATE) {
 485                 return;
 486         }
 487
 488         static Elm_Genlist_Item_Class itc;
 489         //Evas_Object *popup;
 490         Evas_Object *genlist;
 491         int i;
 492         Evas_Object *win = ad->win;
 493
 494         ad->msg_popup = elm_popup_add(win);
 495         elm_popup_align_set(ad->msg_popup, ELM_NOTIFY_ALIGN_FILL, 1.0);
 496         eext_object_event_callback_add(ad->msg_popup, EEXT_CALLBACK_BACK, on_msg_popup_back_cb, ad);
 497         evas_object_size_hint_weight_set(ad->msg_popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 498
 499         evas_object_data_set(ad->msg_popup, "app_data", ad);
 500
 501         genlist = elm_genlist_add(ad->msg_popup);
 502         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 503         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
 504
 505         evas_object_data_set(genlist, "app_data", ad);
 506
 507         itc.item_style = "default";
 508         peer_with_pic_s  *sel_item = ad->peer_in_cahtting_data;
 509         if (sel_item->use_data->peer_type == TGL_PEER_USER) {
 510                 itc.func.text_get = on_messaging_menu_text_get_cb;
 511         } else if (sel_item->use_data->peer_type == TGL_PEER_CHAT) {
 512                 itc.func.text_get = on_messaging_menu_group_text_get_cb;
 513         } else {
 514
 515         }
 516
 517         itc.func.content_get = NULL;
 518         itc.func.state_get = NULL;
 519         itc.func.del = NULL;
 520
 521         if (sel_item->use_data->peer_type == TGL_PEER_CHAT) {
 522                 for (i = 0; i < 2; i++) {
 523                         elm_genlist_item_append(genlist, &itc, (void *) i, NULL, ELM_GENLIST_ITEM_NONE, on_messaging_menu_option_selected_cb, ad);
 524                 }
 525         } else {
 526                 for (i = 0; i < 3; i++) {
 527                         elm_genlist_item_append(genlist, &itc, (void *) i, NULL, ELM_GENLIST_ITEM_NONE, on_messaging_menu_option_selected_cb, ad);
 528                 }
 529         }
 530         evas_object_show(genlist);
 531
 532         elm_object_content_set(ad->msg_popup, genlist);
 533         evas_object_show(ad->msg_popup);
 534 }
 535
 536
 537 /************************ Menu Handler ********************/
 538
 539
 540
 541
 542 static Evas_Object *create_image_object_from_file(const char *icon_name, Evas_Object *parent)
 543 {
 544         Evas_Object *icon = elm_image_add(parent);
 545         evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 546         evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL);
 547         elm_image_file_set(icon, icon_name, NULL);
 548         evas_object_show(icon);
 549         return icon;
 550 }
 551
 552 void on_chat_profile_pic_changed(appdata_s *ad, char *file_path)
 553 {
 554         if (!ad || !file_path) {
 555                 return;
 556         }
 557
 558         Evas_Object *profile_image = evas_object_data_get(ad->nf, "profile_picture");
 559         if (profile_image) {
 560                 elm_image_file_set(profile_image, file_path, NULL);
 561         }
 562
 563 }
 564
 565 void on_group_chat_info_changed(appdata_s *ad, char *type_of_change)
 566 {
 567         if (!ad || !type_of_change) {
 568                 return;
 569         }
 570         if (strstr(type_of_change, "edit_title") != NULL) {
 571                 peer_with_pic_s *sel_item = ad->peer_in_cahtting_data;
 572                 if (sel_item) {
 573                         tg_peer_info_s* user = sel_item->use_data;
 574                         char* user_name = replace(sel_item->use_data->print_name, '_', " ");
 575                         char temp_name[512] = {'\0'};
 576                         snprintf(temp_name, 512, "%s", user_name);
 577                         free(user_name);
 578                         Elm_Object_Item *nf_it = evas_object_data_get(ad->nf, "navi_item");
 579                         elm_object_item_part_text_set(nf_it, "title", temp_name);
 580                 }
 581         } else if (strstr(type_of_change, "delete_photo") != NULL) {
 582
 583         } else if (strstr(type_of_change, "add_user") != NULL) {
 584                 peer_with_pic_s *sel_item = ad->peer_in_cahtting_data;
 585                 if (sel_item) {
 586                         on_user_presence_state_changed(ad, sel_item->use_data->peer_id);
 587                 }
 588         } else if (strstr(type_of_change, "delete_user") != NULL) {
 589                 peer_with_pic_s *sel_item = ad->peer_in_cahtting_data;
 590                 if (sel_item) {
 591                         on_user_presence_state_changed(ad, sel_item->use_data->peer_id);
 592                 }
 593         } else {
 594
 595         }
 596 }
 597
 598 void on_sent_media_item_clicked(void* data, Evas_Object* layout, void* event_info)
 599 {
 600         appdata_s* ad = evas_object_data_get(layout, "app_data");
 601         char* media_type_str = evas_object_data_get(layout, "media_type");
 602         char* media_file = evas_object_data_get(layout, "media_file");
 603
 604         if (access(media_file, F_OK) != -1) {
 605
 606         } else {
 607                 media_file = NULL;
 608         }
 609
 610         if (media_file && strlen(media_file) > 0) {
 611                 app_control_h app_control;
 612                 int ret = app_control_create(&app_control);
 613                 if (ret != APP_CONTROL_ERROR_NONE) {
 614                         show_toast(ad, "Error: Can not load image");
 615                         return;
 616                 }
 617                 app_control_set_operation(app_control, APP_CONTROL_OPERATION_VIEW);
 618                 if (media_type_str && strstr(media_type_str, "video") != NULL) {
 619                         app_control_set_mime(app_control, "video/*");
 620                 } else if (media_type_str && strstr(media_type_str, "audio") != NULL) {
 621                         app_control_set_mime(app_control, "audio/*");
 622                 } else {
 623                         app_control_set_mime(app_control, "image/*");
 624                 }
 625                 app_control_set_uri(app_control, media_file);
 626
 627                 app_control_send_launch_request(app_control, NULL, NULL);
 628                 app_control_destroy(app_control);
 629         }
 630 }
 631
 632 static Evas_Object *get_gif_image_from_path(const char* path, Evas_Object* parent, char *key)
 633 {
 634         if (!path || !parent || !key) {
 635                         return NULL;
 636                 }
 637         LOGD("key : %s", key);
 638         Evas_Object *media_image = elm_image_add(parent);
 639         elm_image_aspect_fixed_set(media_image, EINA_FALSE);
 640         elm_image_file_set(media_image, path, key);
 641         evas_object_size_hint_weight_set(media_image, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 642         evas_object_size_hint_align_set(media_image, EVAS_HINT_FILL, EVAS_HINT_FILL);
 643         evas_object_show(media_image);
 644         return media_image;
 645 }
 646
 647 static Evas_Object *get_image_from_path(const char* path, Evas_Object* parent)
 648 {
 649         if (!path || !parent) {
 650                 return NULL;
 651         }
 652         Evas_Object *media_image = elm_image_add(parent);
 653         elm_image_aspect_fixed_set(media_image, EINA_FALSE);
 654         elm_image_file_set(media_image, path, NULL);
 655         evas_object_size_hint_weight_set(media_image, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 656         evas_object_size_hint_align_set(media_image, EVAS_HINT_FILL, EVAS_HINT_FILL);
 657         evas_object_show(media_image);
 658         return media_image;
 659 }
 660
 661 int get_image_size(long long media_id)
 662 {
 663         Eina_List* media_sizes = get_image_sizes_from_db(media_id);
 664         int row_count = eina_list_count(media_sizes);
 665         int size1 = 0;
 666         int size2 = 0;
 667         int size3 = 0;
 668         int size4 = 0;
 669         int media_size = 0;
 670         for (int i = 0 ; i < row_count ; i++) {
 671                 Eina_List* row_vals = eina_list_nth(media_sizes, i);
 672                 int *temp_size1 = (int *)eina_list_nth(row_vals, 0);
 673                 if (temp_size1) {
 674                         size1 = *temp_size1;
 675                         free(temp_size1);
 676                 }
 677                 int *temp_size2 = (int*)eina_list_nth(row_vals, 3);
 678                 if (temp_size2) {
 679                         size2 = *temp_size2;
 680                         free(temp_size2);
 681                 }
 682                 int *temp_size3 = (int*)eina_list_nth(row_vals, 6);
 683                 if (temp_size3) {
 684                         size3 = *temp_size3;
 685                         free(temp_size3);
 686                 }
 687                 int *temp_size4 = (int*)eina_list_nth(row_vals, 9);
 688                 if (temp_size4) {
 689                         size4 = *temp_size4;
 690                         free(temp_size4);
 691                 }
 692                 eina_list_free(row_vals);
 693                 break;
 694         }
 695         eina_list_free(media_sizes);
 696
 697         if (size1 > 0) {
 698                 media_size = size1;
 699         } else if (size2 > 0) {
 700                 media_size = size2;
 701         } else if (size3 > 0) {
 702                 media_size = size3;
 703         } else if (size4 > 0) {
 704                 media_size = size4;
 705         } else {
 706
 707         }
 708         return media_size;
 709 }
 710
 711 void on_media_chat_item_clicked(void* data, Evas_Object *entry, void* event_info)
 712 {
 713         Evas_Object *button = evas_object_data_get(entry, "button_object");
 714         if (button) {
 715                 char* img_state = evas_object_data_get(button, "image_state");
 716                 if (img_state && strstr(img_state, "download_in_progress") != NULL) {
 717                         return;
 718                 }
 719         }
 720
 721         appdata_s* ad = evas_object_data_get(entry, "app_data");
 722         char *temp_media_id = evas_object_data_get(entry, "media_id");
 723         char *media_type_str = evas_object_data_get(entry, "media_type");
 724
 725         if (media_type_str && strstr(media_type_str, "location") != NULL) {
 726                 char *url = evas_object_data_get(entry, "location_url");
 727                 launch_app_control(ad, media_type_str, url);
 728                 return;
 729         }
 730
 731         long long media_id = atoll(temp_media_id);
 732
 733         char *media_file = get_media_path_from_db(media_id);
 734
 735         if (access(media_file, F_OK) != -1) {
 736
 737         } else {
 738                 media_file = NULL;
 739         }
 740
 741         if (!media_file || strlen(media_file) <= 0) {
 742                 Eina_Bool ret = send_request_for_media_downloading(ad, ad->service_client, ad->peer_in_cahtting_data->use_data->peer_id, media_id);
 743                 if (!ret) {
 744                         show_toast(ad, "Please check your network connection.");
 745                         return;
 746                 }
 747                 // show progress bar
 748                 char temp_msg[256] = {0,};
 749             snprintf(temp_msg, sizeof(temp_msg), "%s", "Downloading...");
 750                 elm_object_part_text_set(button, "size", temp_msg);
 751
 752                 Evas_Object* progressbar = elm_progressbar_add(button);
 753                 elm_object_style_set(progressbar, "process_small");
 754                 evas_object_size_hint_align_set(progressbar, EVAS_HINT_FILL, EVAS_HINT_FILL);
 755                 evas_object_size_hint_weight_set(progressbar, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 756                 elm_progressbar_pulse(progressbar, EINA_TRUE);
 757                 evas_object_show(progressbar);
 758
 759                 Evas_Object* old_content = elm_object_part_content_unset(button, "download_image");
 760                 if (old_content) {
 761                         evas_object_del(old_content);
 762                 }
 763
 764                 elm_object_part_content_set(button, "download_image", progressbar);
 765                 evas_object_data_set(button, "image_state", "download_in_progress");
 766
 767         } else {
 768                 launch_app_control(ad, media_type_str, media_file);
 769         }
 770 }
 771
 772 static void on_video_play_pressed(void *data, Evas_Object *obj, void *event_info)
 773 {
 774         if (!data)
 775                 return;
 776         elm_image_file_set(data, ui_utils_get_resource(TG_PLAY_PRESS_ICON), NULL);
 777 }
 778
 779 static void on_video_play_unpressed(void *data, Evas_Object *obj, void *event_info)
 780 {
 781         if (!data)
 782                 return;
 783         elm_image_file_set(data, ui_utils_get_resource(TG_PLAY_NORMAL_ICON), NULL);
 784 }
 785
 786 static Evas_Object* get_video_paly_icon(Evas_Object *parent)
 787 {
 788         Evas_Object* play_pause_btn = elm_button_add(parent);
 789         elm_object_style_set(play_pause_btn, "transparent");
 790         evas_object_size_hint_align_set(play_pause_btn, EVAS_HINT_FILL, EVAS_HINT_FILL);
 791         evas_object_size_hint_weight_set(play_pause_btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 792
 793         Evas_Object* play_pause_icon = elm_image_add(parent);
 794         evas_object_size_hint_align_set(play_pause_icon, EVAS_HINT_FILL, EVAS_HINT_FILL);
 795         evas_object_size_hint_weight_set(play_pause_icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 796
 797         elm_image_file_set(play_pause_icon, ui_utils_get_resource(TG_PLAY_NORMAL_ICON), NULL);
 798
 799         elm_image_resizable_set(play_pause_icon, EINA_TRUE, EINA_TRUE);
 800         evas_object_show(play_pause_icon);
 801
 802         elm_object_content_set(play_pause_btn, play_pause_icon);
 803
 804         evas_object_smart_callback_add(play_pause_btn, "pressed", on_video_play_pressed, play_pause_icon);
 805         evas_object_smart_callback_add(play_pause_btn, "unpressed", on_video_play_unpressed, play_pause_icon);
 806         return play_pause_btn;
 807 }
 808
 809 static Evas_Object *get_media_layout_with_play(char *img_path, Evas_Object *parent, Eina_Bool show_play_icon)
 810 {
 811         char edj_path[PATH_MAX] = {0, };
 812         app_get_resource(TELEGRAM_INIT_VIEW_EDJ, edj_path, (int)PATH_MAX);
 813         Evas_Object *rec_video_layout = elm_layout_add(parent);
 814         elm_layout_file_set(rec_video_layout, edj_path, "bubble_video_item_layout");
 815         evas_object_size_hint_weight_set(rec_video_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 816         evas_object_size_hint_align_set(rec_video_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 817         evas_object_show(rec_video_layout);
 818
 819         Evas_Object *vid_thumb_icon = get_image_from_path(img_path, parent);
 820         elm_object_part_content_set(rec_video_layout, "swallow.video_thumb_item", vid_thumb_icon);
 821
 822         if (show_play_icon) {
 823 /*              Evas_Object* play_img = get_image_from_path(ui_utils_get_resource(MEDIA_PLAY_ICON), parent);
 824                 elm_object_part_content_set(rec_video_layout, "swallow.play_btn", play_img);*/
 825
 826                 Evas_Object* play_pause_btn = get_video_paly_icon(parent);
 827                 elm_object_part_content_set(rec_video_layout, "swallow.play_btn", play_pause_btn);
 828         }
 829
 830         return rec_video_layout;
 831 }
 832
 833 void audio_player_progress_updated(void* handler, int current, int total, void *user_data)
 834 {
 835         Evas_Object *parent = user_data;
 836         Evas_Object *progressbar = evas_object_data_get(parent, "progress_control");
 837
 838
 839         int seconds = (int) (current / 1000) % 60 ;
 840         int minutes = (int) ((current / (1000*60)) % 60);
 841
 842         char tot_dur[256] = {0,};
 843         char *format = NULL;
 844         if (seconds < 10 && minutes < 10) {
 845                 format = "0%d:0%d";
 846         } else if (seconds > 10 && minutes < 10) {
 847                 format = "%d:0%d";
 848         } else if (seconds < 10 && minutes > 10) {
 849                 format = "0%d:%d";
 850         } else {
 851                 format = "0%d:0%d";
 852         }
 853
 854         sprintf(tot_dur, format, minutes, seconds);
 855         elm_object_part_text_set(progressbar, "elm.text.bottom.right", tot_dur);
 856
 857         double current_status = (double)((double)current/(double)total);
 858
 859         elm_progressbar_value_set(progressbar, current_status);
 860
 861 }
 862
 863 void audio_player_state_changed(void* handler, TG_AUDIO_PLAYER_STATE state, void *user_data)
 864 {
 865         tg_player_handler *audio_payer = handler;
 866         Evas_Object *parent = user_data;
 867
 868         if (!audio_payer || !parent) {
 869                 return;
 870         }
 871
 872         Eina_Bool is_play_mode = (Eina_Bool)evas_object_data_get(parent, "is_play_mode");
 873         switch (audio_payer->state) {
 874         case TG_AUDIO_PLAYER_STATE_NONE:
 875                 break;
 876         case TG_AUDIO_PLAYER_STATE_INITIALIZED:
 877                 evas_object_data_set(parent, "tg_audio_player", audio_payer);
 878                 play_audio_player(audio_payer);
 879                 break;
 880         case TG_AUDIO_PLAYER_STATE_PLAYING:
 881                 elm_image_file_set(parent, ui_utils_get_resource(TG_PAUSE_NORMAL_ICON), NULL);
 882                 is_play_mode = !is_play_mode;
 883                 evas_object_data_set(parent, "is_play_mode", is_play_mode);
 884                 break;
 885         case TG_AUDIO_PLAYER_STATE_INTERRUPTED:
 886                 elm_image_file_set(parent, ui_utils_get_resource(TG_PLAY_NORMAL_ICON), NULL);
 887                 is_play_mode = !is_play_mode;
 888                 evas_object_data_set(parent, "is_play_mode", is_play_mode);
 889                 break;
 890         case TG_AUDIO_PLAYER_STATE_PAUSE:
 891                 elm_image_file_set(parent, ui_utils_get_resource(TG_PLAY_NORMAL_ICON), NULL);
 892                 is_play_mode = !is_play_mode;
 893                 evas_object_data_set(parent, "is_play_mode", is_play_mode);
 894                 break;
 895         case TG_AUDIO_PLAYER_STATE_ERROR:
 896                 break;
 897         case TG_AUDIO_PLAYER_STATE_END:
 898                 destroy_audio_player(audio_payer);
 899                 free(audio_payer);
 900
 901                 is_play_mode = EINA_FALSE;
 902                 evas_object_data_set(parent, "is_play_mode", is_play_mode);
 903                 evas_object_data_set(parent, "tg_audio_player", NULL);
 904                 elm_image_file_set(parent, ui_utils_get_resource(TG_PLAY_NORMAL_ICON), NULL);
 905                 audio_player_progress_updated(NULL, 0, 1, parent);
 906                 break;
 907         default:
 908                 break;
 909         }
 910
 911 }
 912
 913 static void on_message_play_pause_clicked(void *data, Evas_Object *obj, void *event_info)
 914 {
 915         if (!data)
 916                 return;
 917
 918         appdata_s * ad = evas_object_data_get(data, "app_data");
 919         char *audio_file = evas_object_data_get(data, "audio_file_path");
 920         char *media_id = evas_object_data_get(data, "media_id");
 921         if (!audio_file  || strlen(audio_file) <= 0 || (audio_file && strstr(audio_file, "_null_")) != NULL) {
 922                 //there is no file. download it.
 923                 Evas_Object *progressbar = evas_object_data_get(data, "progress_control");
 924                 Eina_Bool is_download_in_progress = (Eina_Bool)evas_object_data_get(progressbar, "is_download_in_progress");
 925
 926                 if (is_download_in_progress) {
 927
 928                 } else {
 929                         elm_object_style_set(progressbar, "pending");
 930                         Eina_Bool ret = send_request_for_media_downloading(ad, ad->service_client, ad->peer_in_cahtting_data->use_data->peer_id, atoll(media_id));
 931                         if (!ret) {
 932                                 show_toast(ad, "Please check your network connection.");
 933                                 return;
 934                         }
 935                 }
 936                 return;
 937         }
 938
 939         tg_player_handler *audio_payer = evas_object_data_get(data, "tg_audio_player");
 940
 941         if (!audio_payer) {
 942                 audio_payer = init_audio_player(audio_file, &audio_player_state_changed, &audio_player_progress_updated, data);
 943
 944                 if (!audio_payer) {
 945                         show_toast(ad, "Unsupported file.");
 946                 }
 947                 return;
 948         }
 949
 950         if (audio_payer->state == TG_AUDIO_PLAYER_STATE_PAUSE || audio_payer->state == TG_AUDIO_PLAYER_STATE_INTERRUPTED) {
 951
 952                 play_audio_player(audio_payer);
 953
 954         } else if (audio_payer->state == TG_AUDIO_PLAYER_STATE_PLAYING) {
 955
 956                 pause_audio_player(audio_payer);
 957
 958         }
 959 }
 960
 961 static void on_message_play_pause_pressed(void *data, Evas_Object *obj, void *event_info)
 962 {
 963         if (!data)
 964                 return;
 965
 966         Eina_Bool is_play_mode = (Eina_Bool)evas_object_data_get(data, "is_play_mode");
 967         if (is_play_mode) {
 968                 elm_image_file_set(data, ui_utils_get_resource(TG_PAUSE_PRESS_ICON), NULL);
 969         } else {
 970                 elm_image_file_set(data, ui_utils_get_resource(TG_PLAY_PRESS_ICON), NULL);
 971         }
 972 }
 973
 974 static void on_message_play_pause_unpressed(void *data, Evas_Object *obj, void *event_info)
 975 {
 976         if (!data)
 977                 return;
 978
 979         Eina_Bool is_play_mode = (Eina_Bool)evas_object_data_get(data, "is_play_mode");
 980         if (is_play_mode) {
 981
 982                 elm_image_file_set(data, ui_utils_get_resource(TG_PAUSE_NORMAL_ICON), NULL);
 983         } else {
 984                 elm_image_file_set(data, ui_utils_get_resource(TG_PLAY_NORMAL_ICON), NULL);
 985         }
 986 }
 987
 988 static void progressbar_del_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
 989 {
 990
 991
 992 }
 993
 994 static Evas_Object *create_audio_progressbar(Evas_Object *parent, int duration)
 995 {
 996         Evas_Object *progressbar;
 997
 998         progressbar = elm_progressbar_add(parent);
 999         evas_object_size_hint_align_set(progressbar, EVAS_HINT_FILL, 0.5);
1000         evas_object_size_hint_weight_set(progressbar, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1001         elm_progressbar_value_set(progressbar, 0.0);
1002         evas_object_event_callback_add(progressbar, EVAS_CALLBACK_DEL, progressbar_del_cb, NULL);
1003         evas_object_show(progressbar);
1004
1005         elm_object_part_text_set(progressbar, "elm.text.top.left", "");
1006         elm_object_part_text_set(progressbar, "elm.text.top.right", "");
1007
1008         elm_object_part_text_set(progressbar, "elm.text.bottom.right", "00:00");
1009
1010         return progressbar;
1011 }
1012
1013
1014 static Evas_Object *get_audio_layout_with_play(Evas_Object *parent)
1015 {
1016         Evas_Object* chat_scroller = parent;
1017         Evas_Object *rec_video_layout = NULL;
1018         tgl_media_s *media_msg = NULL;
1019         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
1020         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
1021         int message_id = (int)evas_object_data_get(chat_scroller, "message_id");
1022
1023         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
1024         int buddy_id = sel_item->use_data->peer_id;
1025         char* tablename = get_table_name_from_number(buddy_id);
1026
1027         tg_message_s* msg = get_message_from_message_table(message_id, tablename);
1028
1029         free(tablename);
1030
1031         if (!msg) {
1032                 return NULL;
1033         }
1034
1035         Evas_Object *parent_obj = evas_object_data_get(chat_scroller, "parent_obj"); //entry
1036
1037         //if (msg->out) {
1038
1039                 media_msg = get_media_details_from_db(atoll(msg->media_id));
1040
1041                 char *audio_file = media_msg->file_path;
1042
1043                 char edj_path[PATH_MAX] = {0, };
1044                 app_get_resource(TELEGRAM_INIT_VIEW_EDJ, edj_path, (int)PATH_MAX);
1045                 rec_video_layout = elm_layout_add(parent);
1046                 elm_layout_file_set(rec_video_layout, edj_path, "bubble_audio_item_layout");
1047                 evas_object_size_hint_weight_set(rec_video_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1048                 evas_object_size_hint_align_set(rec_video_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1049                 evas_object_show(rec_video_layout);
1050
1051                 /**************** play icon **********************/
1052                 Evas_Object* play_pause_btn = elm_button_add(parent);
1053                 elm_object_style_set(play_pause_btn, "transparent");
1054                 evas_object_size_hint_align_set(play_pause_btn, EVAS_HINT_FILL, EVAS_HINT_FILL);
1055                 evas_object_size_hint_weight_set(play_pause_btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1056
1057                 Evas_Object* play_pause_icon = elm_image_add(parent);
1058                 evas_object_size_hint_align_set(play_pause_icon, EVAS_HINT_FILL, EVAS_HINT_FILL);
1059                 evas_object_size_hint_weight_set(play_pause_icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1060                 elm_image_file_set(play_pause_icon, ui_utils_get_resource(TG_PLAY_NORMAL_ICON), NULL);
1061
1062                 elm_image_resizable_set(play_pause_icon, EINA_TRUE, EINA_TRUE);
1063                 evas_object_show(play_pause_icon);
1064                 elm_object_content_set(play_pause_btn, play_pause_icon);
1065
1066                 Eina_Bool is_play_mode = EINA_TRUE;
1067                 evas_object_data_set(play_pause_icon, "is_play_mode", is_play_mode);
1068
1069                 if (audio_file) {
1070                         evas_object_data_set(play_pause_icon, "audio_file_path", strdup(audio_file));
1071                 }
1072                 evas_object_data_set(play_pause_icon, "app_data", ad);
1073                 evas_object_data_set(play_pause_icon, "user_id", (void*)user_id);
1074                 evas_object_data_set(play_pause_icon, "message_id", (void*)message_id);
1075                 evas_object_data_set(play_pause_icon, "media_id", strdup(msg->media_id));
1076
1077                 evas_object_smart_callback_add(parent_obj, "clicked", on_message_play_pause_clicked, play_pause_icon);
1078                 evas_object_smart_callback_add(parent_obj, "pressed", on_message_play_pause_pressed, play_pause_icon);
1079                 evas_object_smart_callback_add(parent_obj, "unpressed", on_message_play_pause_unpressed, play_pause_icon);
1080
1081                 evas_object_smart_callback_add(play_pause_btn, "clicked", on_message_play_pause_clicked, play_pause_icon);
1082                 evas_object_smart_callback_add(play_pause_btn, "pressed", on_message_play_pause_pressed, play_pause_icon);
1083                 evas_object_smart_callback_add(play_pause_btn, "unpressed", on_message_play_pause_unpressed, play_pause_icon);
1084                 elm_object_part_content_set(rec_video_layout, "swallow.play_icon", play_pause_btn);
1085                 /**************** play icon **********************/
1086
1087                 /*************** progress bar ********************/
1088
1089                 int total_duration = 0;
1090                 if (audio_file) {
1091                         metadata_extractor_h metadata;
1092                         metadata_extractor_create(&metadata);
1093                         int ret = metadata_extractor_set_path(metadata, audio_file);
1094                         char *value = NULL;
1095                         ret = metadata_extractor_get_metadata(metadata, METADATA_DURATION, &value);
1096                         metadata_extractor_destroy(metadata);
1097
1098                         if (value) {
1099                                 total_duration = atoi(value);
1100                                 free(value);
1101                         }
1102                 } else {
1103                         total_duration = media_msg->doc_duration;
1104                         //convert into milli secs
1105                         total_duration = 1000 * total_duration;
1106                 }
1107
1108                 Evas_Object *progress = create_audio_progressbar(parent, total_duration);
1109
1110                 evas_object_data_set(parent_obj, "play_pause_icon", play_pause_icon);
1111                 evas_object_data_set(parent_obj, "progress_bar", progress);
1112
1113                 elm_object_part_content_set(rec_video_layout, "swallow.progress_icon", progress);
1114
1115                 evas_object_data_set(play_pause_icon, "progress_control", (void*)progress);
1116                 Eina_Bool is_download_in_progress = EINA_FALSE;
1117                 evas_object_data_set(progress, "is_download_in_progress", (void*)is_download_in_progress);
1118
1119                 /*************** progress bar ********************/
1120
1121         //}
1122
1123         if (msg->message) {
1124                 free(msg->message);
1125                 msg->message = NULL;
1126         }
1127         if (msg->media_id) {
1128                 free(msg->media_id);
1129                 msg->media_id = NULL;
1130         }
1131         free(msg);
1132         free_media_details(media_msg);
1133
1134         return rec_video_layout;
1135 }
1136
1137
1138 static Evas_Object * item_provider(void *data, Evas_Object *entry, const char *item)
1139 {
1140         Evas_Object *layout = NULL;
1141         if (!strcmp(item, "itemprovider")) {
1142                 Evas_Object* chat_scroller = data;
1143                 appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
1144                 int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
1145                 int message_id = (int)evas_object_data_get(entry, "message_id");
1146
1147                 peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
1148                 int buddy_id = sel_item->use_data->peer_id;
1149
1150                 char* tablename = get_table_name_from_number(buddy_id);
1151                 tg_message_s* msg = get_message_from_message_table(message_id, tablename);
1152                 free(tablename);
1153                 if (!msg) {
1154                         return NULL;
1155                 }
1156                 Evas_Object *item_to_display = NULL;
1157                 tgl_media_s *media_msg = NULL;
1158                 if (msg->media_type == tgl_message_media_photo || msg->media_type == tgl_message_media_document) {
1159
1160                         Eina_Bool is_blur_image = EINA_FALSE;
1161                         char* img_path = NULL;
1162
1163                         img_path = get_media_path_from_db(atoll(msg->media_id));
1164                         if (access(img_path, F_OK) == -1) {
1165                                 const char *tmp;
1166                                 tmp = ui_utils_get_resource(BLUR_BG);
1167                                 img_path = strdup(tmp);
1168                                 is_blur_image = EINA_TRUE;
1169                         }
1170
1171                         if (msg->media_type == tgl_message_media_document) {
1172                                 media_msg = get_media_details_from_db(atoll(msg->media_id));
1173
1174                                 if (media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "video") != NULL) {
1175                                         if (img_path == NULL || strlen(img_path) == 0) {
1176                                                 img_path = strdup(ui_utils_get_resource(TG_VIDEO_ICON));
1177                                         }
1178                                 }
1179                                 if (media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "audio") != NULL) {
1180                                         if (img_path) {
1181                                                 free(img_path);
1182                                                 img_path = NULL;
1183                                         }
1184                                         img_path = strdup(ui_utils_get_resource(TG_AUDIO_ICON));
1185                                 }
1186                                 char* media_file = get_media_path_from_db(atoll(msg->media_id));
1187                                 if (!media_file || (media_file && !strcmp(media_file, "_null_")) || (media_file && strlen(media_file) <= 0) ||  (media_file && access(media_file, F_OK) == -1)) {
1188                                         is_blur_image = EINA_TRUE;
1189                                 }
1190
1191                                 if (media_file && strstr(media_file, ".webp") != NULL) {
1192                                         is_blur_image = EINA_FALSE;
1193                                 }
1194                                 free(media_file);
1195
1196                         }
1197
1198                         if (media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "audio") != NULL) {
1199
1200                                 evas_object_data_set(chat_scroller, "parent_obj", (void*)entry);
1201                                 item_to_display = get_audio_layout_with_play(chat_scroller);
1202
1203                         } else if (msg->out) {
1204
1205                                 if (msg->media_type == tgl_message_media_photo) {
1206                                         item_to_display = get_image_from_path(img_path, entry);
1207
1208                                 } else {
1209                                         if (media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "video") != NULL) {
1210                                                 char *thumb_path = get_video_thumb_path_from_db(media_msg->media_id);
1211                                                 if (!thumb_path) {
1212                                                         thumb_path = strdup(ui_utils_get_resource(BLUR_BG));
1213                                                 }
1214                                                 item_to_display = get_media_layout_with_play(thumb_path, entry, EINA_TRUE);
1215                                                 free(thumb_path);
1216                                         } else {
1217                                                 item_to_display = get_image_from_path(img_path, entry);
1218                                                 elm_image_animated_set(item_to_display, EINA_TRUE);
1219                                                 elm_image_animated_play_set(item_to_display, EINA_TRUE);
1220                                         }
1221                                 }
1222
1223                         } else {
1224                                 if (!is_blur_image) {
1225                                         if (msg->media_type == tgl_message_media_photo) {
1226                                                 item_to_display = get_image_from_path(img_path, entry);
1227                                                 evas_object_data_set(entry, "image_object", (void*)item_to_display);
1228                                         } else {
1229                                                 if (media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "video") != NULL) {
1230
1231                                                         //item_to_display = get_media_layout_with_play(img_path, entry, EINA_TRUE);
1232                                                         char *thumb_path = get_video_thumb_path_from_db(media_msg->media_id);
1233                                                         if (!thumb_path) {
1234                                                                 thumb_path = strdup(ui_utils_get_resource(BLUR_BG));
1235                                                         }
1236                                                         item_to_display = get_media_layout_with_play(thumb_path, entry, EINA_TRUE);
1237                                                         free(thumb_path);
1238
1239                                                 } else {
1240                                                         if (media_msg && media_msg->mime_type && strstr(media_msg->mime_type, "webp") != NULL) {
1241                                                                 char *tmp = ui_utils_get_resource(BROKEN_IMAGE);
1242                                                                 //item_to_display = get_image_from_path(img_path, entry);
1243                                                                 // To be fixed
1244                                                                 item_to_display = get_image_from_path(tmp, entry);
1245                                                                 evas_object_data_set(entry, "image_object", (void*)item_to_display);
1246                                                         } else {
1247                                                                 item_to_display = get_image_from_path(img_path, entry);
1248                                                                 evas_object_data_set(entry, "image_object", (void*)item_to_display);
1249                                                                 elm_image_animated_set(item_to_display, EINA_TRUE);
1250                                                                 elm_image_animated_play_set(item_to_display, EINA_TRUE);
1251                                                         }
1252                                                 }
1253                                         }
1254
1255                                 } else {
1256                                         char edj_path[PATH_MAX] = {0, };
1257                                         app_get_resource(TELEGRAM_INIT_VIEW_EDJ, edj_path, (int)PATH_MAX);
1258                                         Evas_Object *rec_img_layout = elm_layout_add(entry);
1259                                         elm_layout_file_set(rec_img_layout, edj_path, "bubble_received_media_layout");
1260                                         evas_object_size_hint_weight_set(rec_img_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1261                                         evas_object_size_hint_align_set(rec_img_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1262                                         evas_object_show(rec_img_layout);
1263                                         Evas_Object *img_item = NULL;
1264
1265
1266                                         if (msg->media_type == tgl_message_media_photo) {
1267                                                 img_item = get_image_from_path(img_path, entry);
1268                                         } else {
1269                                                 if ((media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "video") != NULL) || (media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "audio") != NULL)) {
1270                                                         //img_item = get_media_layout_with_play(img_path, entry, EINA_FALSE);
1271                                                         char *thumb_path = get_video_thumb_path_from_db(media_msg->media_id);
1272                                                         if (!thumb_path) {
1273                                                                 thumb_path = strdup(ui_utils_get_resource(BLUR_BG));
1274                                                         }
1275                                                         img_item = get_media_layout_with_play(thumb_path, entry, EINA_FALSE);
1276                                                         free(thumb_path);
1277                                                 } else {
1278                                                         img_item = get_image_from_path(img_path, entry);
1279                                                 }
1280                                         }
1281                                         elm_object_part_content_set(rec_img_layout, "swallow.image_item", img_item);
1282
1283                                         int media_size = 0;
1284                                         if (msg->media_type == tgl_message_media_photo) {
1285                                                 media_size = get_image_size(atoll(msg->media_id));
1286                                         } else {
1287                                                 if (media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "video") != NULL) {
1288                                                         media_size = get_media_size_from_db(atoll(msg->media_id));
1289                                                 } else if (media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "audio") != NULL) {
1290                                                         media_size = get_media_size_from_db(atoll(msg->media_id));
1291                                                 } else {
1292                                                         media_size = get_media_size_from_db(atoll(msg->media_id));
1293                                                 }
1294                                         }
1295
1296                                         int media_size_kbs = (media_size < (1 << 20)); //convert to kbs
1297                                         char media_size_str[10] = { 0, };
1298                                         if (media_size_kbs > 0) {
1299                                                 sprintf(media_size_str, "%dKB", media_size_kbs);
1300                                         } else {
1301                                                 sprintf(media_size_str, "%dB", media_size);
1302                                         }
1303
1304
1305                                         Evas_Object *size_btn = elm_layout_add(entry);
1306                                         elm_layout_file_set(size_btn, edj_path, "download_btn");
1307                                         elm_object_part_text_set(size_btn, "size", media_size_str);
1308                                         evas_object_size_hint_weight_set(size_btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1309                                         evas_object_size_hint_align_set(size_btn, EVAS_HINT_FILL, EVAS_HINT_FILL);
1310                                         evas_object_show(size_btn);
1311
1312                                         evas_object_data_set(size_btn, "image_state", "ready_to_download");
1313
1314                                         Evas_Object* download_img = get_image_from_path(ui_utils_get_resource(MEDIA_DOWNLOAD_ICON), entry);
1315                                         elm_object_part_content_set(size_btn, "download_image", download_img);
1316
1317                                         elm_object_part_content_set(rec_img_layout, "swallow.download_btn", size_btn);
1318
1319                                         evas_object_data_set(entry, "image_object", (void*)img_item);
1320                                         evas_object_data_set(entry, "button_object", (void*)size_btn);
1321                                         evas_object_data_set(entry, "image_size", (void*)strdup(media_size_str));
1322
1323                                         //ad->loaded_msg_list = eina_list_append(ad->loaded_msg_list, entry);
1324
1325                                         item_to_display = rec_img_layout;
1326                                 }
1327                         }
1328
1329                         if (img_path) {
1330                                 free(img_path);
1331                                 img_path = NULL;
1332                         }
1333                         // delete media details
1334
1335                 }
1336
1337                 evas_object_data_set(entry, "chat_list", (void*)chat_scroller);
1338                 evas_object_data_set(entry, "message_id", (void*)message_id);
1339                 evas_object_data_set(entry, "app_data", (void*)ad);
1340
1341
1342                 if (msg->media_type == tgl_message_media_photo) {
1343                         evas_object_data_set(entry, "media_type", (void*)strdup("image"));
1344                 } else if (msg->media_type == tgl_message_media_geo) {
1345                         evas_object_data_set(entry, "media_type", (void*)strdup("location"));
1346                 } else {
1347                         if (media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "video") != NULL) {
1348                                 evas_object_data_set(entry, "media_type", (void*)strdup("video"));
1349                         } else if (media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "audio") != NULL) {
1350                                 evas_object_data_set(entry, "media_type", (void*)strdup("audio"));
1351                         } else {
1352                                 if (media_msg && media_msg->mime_type && strstr(media_msg->mime_type, "webp") != NULL) {
1353                                         evas_object_data_set(entry, "media_type", (void*)strdup("image"));
1354                                 } else {
1355                                         evas_object_data_set(entry, "media_type", (void*)strdup("animated_gif"));
1356                                 }
1357                         }
1358                 }
1359                 evas_object_data_set(entry, "media_id", (void*)strdup(msg->media_id));
1360                 if (item_to_display) {
1361                         if (media_msg && media_msg->doc_type && strstr(media_msg->doc_type, "audio") != NULL) {
1362                                 layout = item_to_display;
1363                         } else {
1364                                 char edj_path[PATH_MAX] = {0, };
1365                                 app_get_resource(TELEGRAM_INIT_VIEW_EDJ, edj_path, (int)PATH_MAX);
1366                                 layout = elm_layout_add(entry);
1367                                 elm_layout_file_set(layout, edj_path, "chat_image_layout");
1368                                 evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1369                                 evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1370                                 evas_object_show(layout);
1371
1372                                 Evas_Object *rounded_layout = elm_layout_add(entry);
1373                                 elm_layout_file_set(rounded_layout, edj_path, "rounded_corner_layout");
1374                                 evas_object_size_hint_weight_set(rounded_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1375                                 evas_object_size_hint_align_set(rounded_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1376                                 evas_object_show(rounded_layout);
1377                                 elm_object_part_content_set(rounded_layout, "content", item_to_display);
1378
1379                                 elm_object_part_content_set(layout, "swallow.chat_image", rounded_layout);
1380                                 evas_object_smart_callback_add(entry, "clicked", on_media_chat_item_clicked, NULL);
1381                         }
1382                 }
1383
1384                 if (msg->message) {
1385                         free(msg->message);
1386                         msg->message = NULL;
1387                 }
1388
1389                 if (msg->media_id) {
1390                         free(msg->media_id);
1391                         msg->media_id = NULL;
1392                 }
1393
1394                 free(msg);
1395                 free_media_details(media_msg);
1396         }
1397
1398         return layout;
1399 }
1400
1401 static void __resize_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1402 {
1403         appdata_s *ad = data;
1404         Evas_Object *layout = NULL;
1405         Evas_Object *chat_scroller = NULL;
1406
1407         layout = evas_object_data_get(ad->nf, "main_layout");
1408         chat_scroller = evas_object_data_get(ad->nf, "chat_list");
1409
1410         int is_end_edge = 0;
1411         is_end_edge = (int)evas_object_data_get(layout, "is_end_edge");
1412         int is_end_edge_top = 0;
1413         is_end_edge_top = (int)evas_object_data_get(chat_scroller, "is_end_edge_top");
1414         if (is_end_edge) {
1415                 int ret = 1;
1416                 /*if(is_end_edge_top)
1417                         ret = scroller_show_previous_region(chat_scroller);
1418                 else*/
1419                         ret = scroller_show_bottom_edge(chat_scroller);
1420                 if (!ret) {
1421                         LOGE("Fail to show the bottom of scroller");
1422                 }
1423         }
1424         if(is_end_edge_top)
1425                 scroller_show_previous_region(chat_scroller);
1426 }
1427
1428 //static void free_data_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1429 //{
1430 //      free(data);
1431 //}
1432
1433 static void set_string_data(Evas_Object *obj, const char *key, const char *data)
1434 {
1435         char *previous_str;
1436         char *new_data;
1437
1438         previous_str = evas_object_data_del(obj, key);
1439         if (previous_str) {
1440                 //evas_object_event_callback_del(obj, EVAS_CALLBACK_DEL, free_data_cb);
1441                 free(previous_str);
1442         }
1443
1444         if (data) {
1445                 new_data = strdup(data);
1446                 if (!new_data) {
1447                         // LOG
1448                         return;
1449                 }
1450
1451                 evas_object_data_set(obj, key, new_data);
1452                 //evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, free_data_cb, new_data);
1453         }
1454 }
1455
1456 static void _create_image_item(tg_message_s *msg, Evas_Object *entry, char *image, int size)
1457 {
1458         char* img_path = NULL;
1459         int w, h, entry_h;
1460         Evas_Object *img_item = NULL;
1461
1462         w = 0;
1463         h = 0;
1464
1465         img_path = get_video_thumb_path_from_db(atoll(msg->media_id));
1466         if (img_path == NULL || (img_path && strlen(img_path) == 0) || (img_path && strstr(img_path, "_null_") != NULL)) {
1467                 img_path = get_media_path_from_db(atoll(msg->media_id));
1468                 if (access(img_path, F_OK) == -1) {
1469                         img_path = NULL;
1470                 }
1471         }
1472
1473         if (img_path) {
1474                 if (strstr(img_path, ".webp") != NULL) {
1475                         char *tmp = ui_utils_get_resource(BROKEN_IMAGE);
1476                         LOGE("broken image(webp): %s", tmp);
1477                         // To Be Fixed.
1478                         //img_item = get_image_from_path(img_path, entry);
1479                         img_item = get_image_from_path(tmp, entry);
1480                         entry_h = 200;
1481                 } else {
1482                         if (msg->media_type == tgl_message_media_document) {
1483                                 char key[256] = {0, };
1484                                 snprintf(key, sizeof(key), "%d", msg->msg_id);
1485                                 img_item = get_gif_image_from_path(img_path, entry, key);
1486                         } else {
1487                                 img_item = get_image_from_path(img_path, entry);
1488                         }
1489                         elm_image_object_size_get(img_item, &w, &h);
1490                         entry_h = (318 * h) / w;
1491                 }
1492                 free(img_path);
1493         } else {
1494                 entry_h = 200;
1495         }
1496
1497         snprintf(image, size - 1, "<item size=318x%d vsize=full href=itemprovider></item>", entry_h);
1498 }
1499
1500 Evas_Object *on_message_item_content_get_cb(void *data, Evas_Object *obj, const char *part)
1501 {
1502         Evas_Object *entry = NULL;
1503         Evas_Object *layout = NULL;
1504
1505         if (data == NULL) {
1506                 ERR("Invalid Parameter.");
1507                 return NULL;
1508         }
1509
1510         char edj_path[PATH_MAX] = {0, };
1511         app_get_resource(TELEGRAM_INIT_VIEW_EDJ, edj_path, (int)PATH_MAX);
1512
1513         if (!strcmp(part, "elm.icon.entry")) {
1514
1515                 tg_message_s *msg = (tg_message_s*)data;
1516                 Evas_Object *chat_scroller = obj;
1517                 appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
1518
1519                 Evas_Object *nomsg_layout = evas_object_data_get(ad->nf, "chat_list_no_msg_text");
1520                 if (nomsg_layout) {
1521                         elm_object_signal_emit(nomsg_layout, "hide", "message");
1522                 }
1523
1524                 int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
1525                 evas_object_data_set(chat_scroller, "message_id", msg->msg_id);
1526
1527                 peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
1528                 int buddy_id = sel_item->use_data->peer_id;
1529
1530                 char* tablename = get_table_name_from_number(buddy_id);
1531
1532                 //Eina_Bool is_blur_image = EINA_FALSE;
1533
1534                 if (msg) {
1535 #if 0
1536                         if (msg->unread) {
1537                                 msg->unread = 0;
1538                                 update_msg_into_db(msg, tablename);
1539                                 ad->is_last_msg_changed = EINA_TRUE;
1540                         }
1541 #endif
1542                         if (msg->out) {
1543
1544                         } else {
1545                                 // update un read
1546
1547                         }
1548
1549                         if (msg->service == 2) {
1550                                 layout = elm_layout_add(obj);
1551                                 elm_layout_file_set(layout, edj_path, "chat_date_item");
1552                                 evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1553                                 evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1554                                 evas_object_show(layout);
1555
1556                                 // convert date from string to int
1557                                 char *date_str = msg->message;
1558                                 int date_num = atoi(date_str);
1559
1560                                 // convert date format
1561                                 time_t t = date_num;
1562                                 char *format = NULL;
1563                                 format = "%a, %e %b %Y";
1564                                 struct tm lt;
1565                                 char res[256];
1566                                 (void) localtime_r(&t, &lt);
1567
1568                                 if (strftime(res, sizeof(res), format, &lt) == 0) {
1569                                         (void) fprintf(stderr,  "strftime(3): cannot format supplied "
1570                                                         "date/time into buffer of size %u "
1571                                                         "using: '%s'\n",
1572                                                         sizeof(res), format);
1573                                 }
1574
1575                                 elm_object_part_text_set(layout, "elm.text", res);
1576                                 return layout;
1577                         } else if (msg->service == 1) {
1578                                 layout = elm_layout_add(obj);
1579                                 elm_layout_file_set(layout, edj_path, "chat_service_item_box");
1580                                 evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1581                                 evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1582                                 evas_object_show(layout);
1583
1584                                 elm_object_part_text_set(layout, "elm.text", msg->message);
1585
1586                                 return layout;
1587                         }
1588
1589                         if (msg->media_type != tgl_message_media_none) {
1590                                 entry = elm_entry_add(obj);
1591                                 elm_entry_editable_set(entry, EINA_FALSE);
1592                                 elm_entry_context_menu_disabled_set(entry, EINA_TRUE);
1593                                 elm_entry_single_line_set(entry, EINA_TRUE);
1594                                 elm_entry_input_panel_enabled_set(entry, EINA_FALSE);
1595                         } else {
1596                                 entry = elm_label_add(obj);
1597                         }
1598
1599                         evas_object_data_set(entry, "message_id", (void*)msg->msg_id);
1600                         // evas_object_data_set(entry, "chat_list", (void*)chat_scroller);
1601
1602                         layout = elm_layout_add(obj);
1603
1604                         if (msg->out) {
1605                                 elm_layout_file_set(layout, edj_path, "entry,send,layout");
1606                                 elm_object_style_set(entry, "sentmessage1");
1607                                 //sender_name = replace(ad->current_user_data->print_name, '_', " ");
1608                         } else {
1609                                 elm_layout_file_set(layout, edj_path, "entry,receive,layout");
1610                                 elm_object_style_set(entry, "readmessage1");
1611
1612                                 /* If you need to get the name, you need this code */
1613                                 /*
1614                                 char *sender_name = NULL;
1615                                 if (sel_item->use_data->peer_type == TGL_PEER_USER) {
1616                                         sender_name = replace(sel_item->use_data->print_name, '_', " ");
1617                                 } else if (sel_item->use_data->peer_type == TGL_PEER_CHAT) {
1618                                         int from_id = msg->from_id;
1619                                         // get name of buddy
1620                                         char* buddy_name = get_buddy_name_from_id(from_id);
1621                                         if (buddy_name) {
1622                                                 sender_name = replace(buddy_name, '_', " ");
1623                                                 free(buddy_name);
1624                                         }
1625                                 } else {
1626                                         sender_name = replace(sel_item->use_data->print_name, '_', " ");
1627                                 }
1628                                 */
1629                         }
1630
1631                         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1632                         elm_object_part_content_set(layout, "elm.swallow.content", entry);
1633                         evas_object_show(layout);
1634
1635                         evas_object_size_hint_weight_set(entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1636                         evas_object_size_hint_align_set(entry, EVAS_HINT_FILL, EVAS_HINT_FILL);
1637                         evas_object_show(entry);
1638                         // To be handled for group chat
1639                         Eina_Strbuf *buf = eina_strbuf_new();
1640                         char *caption = NULL;
1641                         LOGD("entry media type is %d", msg->media_type);
1642                         if (msg->media_type == tgl_message_media_none) {
1643                                 char *temp_msg = replace(msg->message, '\n', "<br>");
1644                                 elm_object_part_text_set(entry, "elm.text", temp_msg);
1645                                 //eina_strbuf_append(buf, temp_msg);
1646                                 //elm_entry_entry_set(entry, eina_strbuf_string_get(buf));
1647                                 eina_strbuf_free(buf);
1648
1649                         } else if (msg->media_type == tgl_message_media_photo || msg->media_type == tgl_message_media_document) {
1650                                 elm_entry_item_provider_append(entry, item_provider, chat_scroller);
1651
1652                                 LOGD("media id[%s]", msg->media_id);
1653                                 tgl_media_s *media_msg = get_media_details_from_db(atoll(msg->media_id));
1654                                 if (media_msg)
1655                                         LOGD("file path[%s]", media_msg->file_path);
1656                                 if (media_msg && media_msg->caption && strlen(media_msg->caption) > 0) {
1657                                         caption = strdup(media_msg->caption);
1658                                         LOGD("caption[%s]", caption);
1659                                 }
1660                                 if (msg->out) {
1661                                         if (media_msg) {
1662                                                 if (media_msg->doc_type && strstr(media_msg->doc_type, "audio") != NULL) {
1663                                                         if (ad->target_direction == TELEGRAM_TARGET_DIRECTION_PORTRAIT || ad->target_direction == TELEGRAM_TARGET_DIRECTION_PORTRAIT_INVERSE) {
1664                                                                 eina_strbuf_append(buf, "<item size=318x100 vsize=full hsize=full href=itemprovider></item>");
1665                                                         } else {
1666                                                                 eina_strbuf_append(buf, "<item size=318x100 vsize=full hsize=full href=itemprovider></item>");
1667                                                         }
1668
1669                                                 } else if (media_msg->doc_type && strstr(media_msg->doc_type, "video") != NULL) {
1670                                                         eina_strbuf_append(buf, "<item size=318x200 vsize=full hsize=full href=itemprovider></item>");
1671                                                 } else {
1672                                                         char image[256] = {0,};
1673                                                         _create_image_item(msg, entry, image, sizeof(image));
1674                                                         eina_strbuf_append(buf, image);
1675                                                 }
1676                                         }
1677                                 } else {
1678                                         if (media_msg) {
1679                                                 if (media_msg->doc_type && strstr(media_msg->doc_type, "audio") != NULL) {
1680                                                         eina_strbuf_append(buf, "<item size=318x100 vsize=full hsize=full href=itemprovider></item>");
1681                                                 } else if (media_msg->doc_type && strstr(media_msg->doc_type, "video") != NULL) {
1682                                                         eina_strbuf_append(buf, "<item size=318x200 vsize=full hsize=full href=itemprovider></item>");
1683                                                 } else {
1684                                                         char image[256] = {0,};
1685                                                         _create_image_item(msg, entry, image, sizeof(image));
1686                                                         eina_strbuf_append(buf, image);
1687                                                 }
1688                                         }
1689                                 }
1690                                 free_media_details(media_msg);
1691                                 elm_entry_entry_set(entry, eina_strbuf_string_get(buf));
1692                                 eina_strbuf_free(buf);
1693                         } else if (msg->media_type == tgl_message_media_geo) {
1694
1695                                 tgl_media_s *media_msg = get_media_details_from_db(atoll(msg->media_id));
1696
1697                                 char loc_url[4*256] = {0,};
1698                                 if (media_msg) {
1699                                         if (media_msg->caption && strlen(media_msg->caption) > 0) {
1700                                                 caption = strdup(media_msg->caption);
1701                                         }
1702                                         snprintf(loc_url, sizeof(loc_url), "https://maps.google.com/?q=%s,%s", media_msg->latitude, media_msg->longitude);
1703                                         char temp_msg[4*256] = {0,};
1704                                         snprintf(temp_msg, sizeof(temp_msg), "<font=Tizen:style=Normal|underline color=#0000FF align=left><font_size=15>%s</font_size></font>", loc_url);
1705                                         eina_strbuf_append(buf, temp_msg);
1706                                         elm_entry_entry_set(entry, eina_strbuf_string_get(buf));
1707                                         eina_strbuf_free(buf);
1708                                 }
1709
1710                                 free_media_details(media_msg);
1711                                 set_string_data(entry, "media_type", "location");
1712                                 set_string_data(entry, "location_url", loc_url);
1713                                 evas_object_smart_callback_add(entry, "clicked", on_media_chat_item_clicked, NULL);
1714
1715                         } else if (msg->media_type == tgl_message_media_contact) {
1716
1717                                 tgl_media_s *media_msg = get_media_details_from_db(atoll(msg->media_id));
1718
1719                                 if (media_msg) {
1720                                         if (media_msg->caption && strlen(media_msg->caption) > 0) {
1721                                                 caption = strdup(media_msg->caption);
1722                                         }
1723                                         char temp_msg[4*256] = {0,};
1724                                         snprintf(temp_msg, sizeof(temp_msg), "<font=Tizen:style=Normal|underline color=#000000 align=left><font_size=15>%s %s, %s</font_size></font>", media_msg->first_name, media_msg->last_name, media_msg->phone_no);
1725                                         eina_strbuf_append(buf, temp_msg);
1726                                         elm_entry_entry_set(entry, eina_strbuf_string_get(buf));
1727                                         eina_strbuf_free(buf);
1728                                         free_media_details(media_msg);
1729                                 }
1730
1731                         } else if (msg->media_type == tgl_message_media_unsupported) {
1732
1733                         } else if (msg->media_type == tgl_message_media_photo_encr) {
1734
1735                         } else if (msg->media_type == tgl_message_media_document_encr) {
1736
1737                         } else  {
1738
1739                         }
1740                         ad->loaded_msg_list = eina_list_append(ad->loaded_msg_list, entry);
1741                         if (caption) {
1742                                 // implement UI.
1743                                 LOGD("caption is (%s)", caption);
1744                                 free(caption);
1745                         }
1746                         //set time
1747                         time_t t = msg->date;
1748                         const char *format = "%I:%M %p";
1749                         struct tm lt;
1750                         char res[32];
1751                         (void) localtime_r(&t, &lt);
1752
1753                         if (strftime(res, sizeof(res), format, &lt) == 0) {
1754                                 (void) fprintf(stderr,  "strftime(3): cannot format supplied "
1755                                                 "date/time into buffer of size %u "
1756                                                 "using: '%s'\n",
1757                                                 sizeof(res), format);
1758                         }
1759
1760                         char time_str[20] = {0,};
1761                         snprintf(time_str, sizeof(time_str) - 1, "%s", res);
1762                         elm_object_part_text_set(entry, "time", time_str);
1763
1764                         Evas_Object *status_obj;
1765                         status_obj = elm_icon_add(entry);
1766                         evas_object_size_hint_weight_set(status_obj, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1767                         evas_object_size_hint_align_set(status_obj, EVAS_HINT_FILL, EVAS_HINT_FILL);
1768
1769                         if (msg->msg_state == TG_MESSAGE_STATE_SENDING) {
1770                                 elm_image_file_set(status_obj, ui_utils_get_resource(MESSAGE_SENDING_ICON), NULL);
1771                                 elm_object_signal_emit(entry, "status_on", "status");
1772                         } else if (msg->msg_state == TG_MESSAGE_STATE_SENT) {
1773                                 elm_image_file_set(status_obj, ui_utils_get_resource(MESSAGE_SENT_ICON), NULL);
1774                                 elm_object_signal_emit(entry, "status_on", "status");
1775                         } else if (msg->msg_state == TG_MESSAGE_STATE_DELIVERED) {
1776                                 elm_image_file_set(status_obj, ui_utils_get_resource(MESSAGE_DELIVERED_ICON), NULL);
1777                                 elm_object_signal_emit(entry, "status_on", "status");
1778                         } else if (msg->msg_state == TG_MESSAGE_STATE_RECEIVED) {
1779                                 elm_object_signal_emit(entry, "status_off", "status");
1780                         } else if (msg->msg_state == TG_MESSAGE_STATE_FAILED) {
1781                                 elm_image_file_set(status_obj, ui_utils_get_resource(MESSAGE_FAILED_ICON), NULL);
1782                                 elm_object_signal_emit(entry, "status_on", "status");
1783                         } else if (msg->msg_state == TG_MESSAGE_STATE_READ) {
1784                                 elm_image_file_set(status_obj, ui_utils_get_resource(MESSAGE_READ_ICON), NULL);
1785                                 elm_object_signal_emit(entry, "status_on", "status");
1786                         } else if (msg->msg_state == TG_MESSAGE_STATE_UNKNOWN) {
1787                                 elm_object_signal_emit(entry, "status_off", "status");
1788                         }
1789
1790                         elm_object_part_content_set(entry, "status_icon", status_obj);
1791                         evas_object_show(status_obj);
1792                         free(tablename);
1793                 }
1794 #if 0
1795                 if (chat_scroller) {
1796                         int size = elm_genlist_items_count(chat_scroller);
1797                         if (size > 0) {
1798                                 Elm_Object_Item *litem = elm_genlist_nth_item_get(chat_scroller, size -1);
1799                                 elm_genlist_item_show(litem, ELM_GENLIST_ITEM_SCROLLTO_TOP);
1800                         }
1801                 }
1802 #endif
1803         }
1804         return layout;
1805 }
1806
1807 void on_text_message_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
1808 {
1809
1810 }
1811
1812 void on_text_message_received_from_buddy(appdata_s* ad, long long message_id, int type_of_chat)
1813 {
1814         if (!ad) {
1815                 return;
1816         }
1817         peer_with_pic_s* pic_peer_item = ad->peer_in_cahtting_data;
1818         tg_peer_info_s* peer_item = pic_peer_item->use_data;
1819         char* tablename = get_table_name_from_number(peer_item->peer_id);
1820         tg_message_s* msg = get_message_from_message_table(message_id, tablename);
1821
1822         Evas_Object* chat_scroller = evas_object_data_get(ad->nf, "chat_list");
1823         Evas_Object *message = NULL;
1824
1825         if (msg == NULL) {
1826                 ERR("msg not found");
1827                 return;
1828         }
1829
1830         // update peer table
1831         if (peer_item) {
1832                 peer_item->last_msg_id = msg->msg_id;
1833                 peer_item->last_msg_date =  msg->date;
1834                 insert_or_update_peer_into_database(peer_item);
1835         }
1836
1837         Evas_Object *layout = evas_object_data_get(ad->nf, "main_layout");
1838         if (layout) {
1839                 int is_end_edge = (int) evas_object_data_get(layout, "is_end_edge");
1840                 if (!is_end_edge) {
1841                         Evas_Object *bubble_layout = NULL;
1842                         bubble_layout = elm_object_part_content_get(layout, "swallow.messagebubble");
1843
1844                         int user_id = (int) evas_object_data_get(chat_scroller, "user_id");
1845                         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
1846                         char *sender_name = NULL;
1847                         if (sel_item->use_data->peer_type == TGL_PEER_USER) {
1848                                 sender_name = replace(sel_item->use_data->print_name, '_', " ");
1849                         } else if (sel_item->use_data->peer_type == TGL_PEER_CHAT) {
1850                                 int from_id = msg->from_id;
1851                                 // get name of buddy
1852                                 char* buddy_name = get_buddy_name_from_id(from_id);
1853                                 if (buddy_name) {
1854                                         sender_name = replace(buddy_name, '_', " ");
1855                                         free(buddy_name);
1856                                 }
1857                         } else {
1858                                 sender_name = replace(sel_item->use_data->print_name, '_', " ");
1859                         }
1860
1861                         elm_object_part_text_set(bubble_layout, "text_name", sender_name);
1862                         elm_object_part_text_set(bubble_layout, "text_message", msg->message);
1863                         elm_object_signal_emit(layout, "show", "bubblemessage");
1864                 }
1865         }
1866
1867         free(tablename);
1868
1869         message = on_message_item_content_get_cb((void *)msg, chat_scroller, "elm.icon.entry");
1870         elm_object_signal_callback_add(message, "clicked", "item", on_text_message_clicked, (void*)message_id);
1871         scroller_push_item(chat_scroller, message, 0);
1872
1873         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
1874         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
1875
1876         send_request_for_marked_as_read(ad, ad->service_client, sel_item->use_data->peer_id, sel_item->use_data->peer_type);
1877         ad->is_last_msg_changed = EINA_TRUE;
1878         on_user_presence_state_changed(ad, sel_item->use_data->peer_id);
1879
1880         if (msg)
1881                 free_message(&msg);
1882 }
1883
1884 static void media_file_del_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1885 {
1886         void *str;
1887         str = evas_object_data_del(obj, data);
1888         free(str);
1889 }
1890
1891
1892 void on_media_download_completed(appdata_s* ad, int buddy_id, long long media_id, const char *file_path, const char *caption)
1893 {
1894         if (!ad)
1895                 return;
1896
1897         if (ad->loaded_msg_list && eina_list_count(ad->loaded_msg_list) > 0) {
1898                 for (int i = eina_list_count(ad->loaded_msg_list) - 1 ; i >= 0; i--) {
1899                         Evas_Object* entry = eina_list_nth(ad->loaded_msg_list, i);
1900                         if (entry) {
1901
1902                                 char* media_type_str = evas_object_data_get(entry, "media_type");
1903                                 char* media_id_str = evas_object_data_get(entry, "media_id");
1904                                 char* media_size_str = evas_object_data_get(entry, "image_size");
1905                                 Evas_Object *img_item = evas_object_data_get(entry, "image_object");
1906                                 Evas_Object *size_btn = evas_object_data_get(entry, "button_object");
1907
1908                                 if (media_id_str) {
1909
1910                                         long long lmedia_id = atoll(media_id_str);
1911
1912                                         if (media_id == lmedia_id) {
1913                                                 if (img_item || (media_type_str && strstr(media_type_str, "audio") != NULL)) {
1914
1915
1916                                                         if (file_path && strstr(file_path, "failed_to_load") != NULL) {
1917
1918                                                                 if (media_type_str && (strstr(media_type_str, "audio") != NULL)) {
1919                                                                         Evas_Object *play_pause_icon = evas_object_data_get(entry, "play_pause_icon");
1920                                                                         Evas_Object *progressbar = evas_object_data_get(entry, "progress_bar");
1921                                                                         evas_object_data_set(progressbar, "is_download_in_progress", (void *)EINA_FALSE);
1922                                                                         set_string_data(play_pause_icon, "audio_file_path", NULL);
1923                                                                         elm_object_style_set(progressbar, "default");
1924                                                                         return;
1925                                                                 }
1926
1927                                                                 // download failed.
1928                                                                 if (size_btn) {
1929                                                                         Evas_Object* progress = elm_object_part_content_get(size_btn, "download_image");
1930                                                                         if (progress) {
1931                                                                                 evas_object_del(progress);
1932                                                                         }
1933                                                                         Evas_Object* download_img = get_image_from_path(ui_utils_get_resource(MEDIA_DOWNLOAD_ICON), size_btn);
1934                                                                         elm_object_part_content_set(size_btn, "download_image", download_img);
1935                                                                         evas_object_data_set(size_btn, "image_state", "ready_to_download");
1936                                                                         char temp_msg[256] = {0,};
1937                                                                         snprintf(temp_msg, sizeof(temp_msg), "<font=Tizen:style=Bold color=#008000 align=center><font_size=30>%s</font_size></font>", media_size_str);
1938                                                                         elm_object_text_set(size_btn, temp_msg);
1939                                                                 }
1940
1941
1942                                                         } else {
1943                                                                 if (media_type_str && (strstr(media_type_str, "audio") != NULL)) {
1944
1945                                                                         Evas_Object *play_pause_icon = evas_object_data_get(entry, "play_pause_icon");
1946                                                                         Evas_Object *progressbar = evas_object_data_get(entry, "progress_bar");
1947                                                                         evas_object_data_set(progressbar, "is_download_in_progress", (void *)EINA_FALSE);
1948                                                                         elm_object_style_set(progressbar, "default");
1949
1950                                                                         set_string_data(play_pause_icon, "audio_file_path", file_path);
1951
1952                                                                         metadata_extractor_h metadata;
1953                                                                         metadata_extractor_create(&metadata);
1954                                                                         int ret = metadata_extractor_set_path(metadata, file_path);
1955                                                                         char *value = NULL;
1956                                                                         ret = metadata_extractor_get_metadata(metadata, METADATA_DURATION, &value);
1957                                                                         metadata_extractor_destroy(metadata);
1958
1959                                                                         int duration = 0;
1960                                                                         if (value) {
1961                                                                                 duration = atoi(value);
1962                                                                                 free(value);
1963                                                                         }
1964
1965                                                                         elm_object_part_text_set(progressbar, "elm.text.top.left", "");
1966                                                                         elm_object_part_text_set(progressbar, "elm.text.top.right", "");
1967
1968                                                                         return;
1969                                                                 }
1970
1971                                                                 if (size_btn) {
1972                                                                         evas_object_del(size_btn);
1973                                                                 }
1974
1975                                                                 if (media_type_str && (strstr(media_type_str, "video") != NULL)) {
1976                                                                         Evas_Object* play_img = get_video_paly_icon(img_item);
1977                                                                         //Evas_Object* play_img = get_image_from_path(ui_utils_get_resource(MEDIA_PLAY_ICON), img_item);
1978                                                                         elm_object_part_content_set(img_item, "swallow.play_btn", play_img);
1979                                                                 } else if (media_type_str && strstr(media_type_str, "image") != NULL) {
1980                                                                         img_item = get_image_from_path(file_path, entry);
1981                                                                         int w, h, entry_h;
1982                                                                         elm_image_object_size_get(img_item, &w, &h);
1983                                                                         entry_h = (318 * h) / w;
1984                                                                         Eina_Strbuf *buf = eina_strbuf_new();
1985                                                                         char image[256] = {0,};
1986                                                                         snprintf(image, sizeof(image) - 1, "<item size=318x%d vsize=full href=itemprovider></item>", entry_h);
1987                                                                         eina_strbuf_append(buf, image);
1988                                                                         elm_entry_entry_set(entry, eina_strbuf_string_get(buf));
1989                                                                         eina_strbuf_free(buf);
1990
1991                                                                 } else if (media_type_str && strstr(media_type_str, "animated_gif") != NULL) {
1992
1993                                                                         int msg_id = (int) evas_object_data_get(entry, "message_id");
1994                                                                         char key[256] = {0, };
1995                                                                         snprintf(key, sizeof(key), "%d", msg_id);
1996
1997                                                                         img_item = get_gif_image_from_path(file_path, entry, key);
1998                                                                         //elm_image_animated_set(img_item, EINA_TRUE);
1999                                                                         //elm_image_animated_play_set(img_item, EINA_TRUE);
2000                                                                         int w, h, entry_h;
2001                                                                         elm_image_object_size_get(img_item, &w, &h);
2002                                                                         entry_h = (318 * h) / w;
2003                                                                         Eina_Strbuf *buf = eina_strbuf_new();
2004                                                                         char image[256] = {0,};
2005                                                                         snprintf(image, sizeof(image) - 1, "<item size=318x%d vsize=full href=itemprovider></item>", entry_h);
2006                                                                         eina_strbuf_append(buf, image);
2007                                                                         elm_entry_entry_set(entry, eina_strbuf_string_get(buf));
2008                                                                         eina_strbuf_free(buf);
2009                                                                 }
2010                                                         }
2011                                                 }
2012                                         }
2013
2014                                 }
2015                         }
2016                 }
2017         }
2018 }
2019
2020 //elm_object_part_content_set(comp_img_layout, "swallow.chat_send_image", image);
2021
2022 void on_video_thumb_download_completed(appdata_s* ad, int buddy_id, long long media_id, const char* file_path, const char *caption)
2023 {
2024         on_media_download_completed(ad, buddy_id, media_id, file_path, caption);
2025 }
2026
2027 void on_text_message_state_changed(appdata_s* ad, tg_message_s *msg, int type_of_chat)
2028 {
2029         if (!ad)
2030                 return;
2031
2032 #if 0
2033         peer_with_pic_s* pic_peer_item = ad->peer_in_cahtting_data;
2034         if (pic_peer_item) {
2035                 tg_peer_info_s* peer_item = pic_peer_item->use_data;
2036                 // update peer table
2037                 if (peer_item) {
2038                         peer_item->last_msg_id = msg->msg_id;
2039                         peer_item->last_msg_date =  msg->date;
2040                         insert_or_update_peer_into_database(peer_item);
2041                 }
2042         }
2043 #endif
2044         if (ad->loaded_msg_list && eina_list_count(ad->loaded_msg_list) > 0) {
2045                 for (int i = eina_list_count(ad->loaded_msg_list) - 1 ; i >= 0; i--) {
2046                         Evas_Object* entry = eina_list_nth(ad->loaded_msg_list, i);
2047
2048                         if (entry) {
2049                                 int message_id = (int)evas_object_data_get(entry, "message_id");
2050                                 if (message_id == msg->msg_id || message_id == msg->unique_id) {
2051
2052                                         set_string_data(entry, "media_id", msg->media_id);
2053                                         evas_object_data_set(entry, "message_id", (void*)message_id);
2054
2055                                         Evas_Object* status_obj = elm_object_part_content_get(entry, "status_icon");
2056                                         if (status_obj) {
2057                                                 if (msg->msg_state == TG_MESSAGE_STATE_SENDING) {
2058                                                         elm_image_file_set(status_obj, ui_utils_get_resource(MESSAGE_SENDING_ICON), NULL);
2059                                                         elm_object_signal_emit(entry, "status_on", "status");
2060                                                 } else if (msg->msg_state == TG_MESSAGE_STATE_SENT) {
2061                                                         elm_image_file_set(status_obj, ui_utils_get_resource(MESSAGE_SENT_ICON), NULL);
2062                                                         elm_object_signal_emit(entry, "status_on", "status");
2063                                                 } else if (msg->msg_state == TG_MESSAGE_STATE_DELIVERED) {
2064                                                         elm_image_file_set(status_obj, ui_utils_get_resource(MESSAGE_DELIVERED_ICON), NULL);
2065                                                         elm_object_signal_emit(entry, "status_on", "status");
2066                                                 } else if (msg->msg_state == TG_MESSAGE_STATE_RECEIVED) {
2067                                                         elm_object_signal_emit(entry, "status_off", "status");
2068                                                 } else if (msg->msg_state == TG_MESSAGE_STATE_FAILED) {
2069                                                         elm_image_file_set(status_obj, ui_utils_get_resource(MESSAGE_FAILED_ICON), NULL);
2070                                                         elm_object_signal_emit(entry, "status_on", "status");
2071                                                 } else if (msg->msg_state == TG_MESSAGE_STATE_READ) {
2072                                                         elm_image_file_set(status_obj, ui_utils_get_resource(MESSAGE_READ_ICON), NULL);
2073                                                         elm_object_signal_emit(entry, "status_on", "status");
2074                                                 } else if (msg->msg_state == TG_MESSAGE_STATE_UNKNOWN) {
2075                                                         elm_object_signal_emit(entry, "status_off", "status");
2076                                                 }
2077                                         }
2078                                         return;
2079                                 }
2080                         }
2081                 }
2082         }
2083 }
2084
2085 Eina_Bool add_date_item_to_chat(void *data)
2086 {
2087         Evas_Object *chat_scroller = data;
2088         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
2089         Eina_Bool ret = EINA_FALSE;
2090         if (!ad) {
2091                 return ret;
2092         }
2093         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
2094         if (!ad->peer_list) {
2095                 return ret;
2096         }
2097
2098         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
2099
2100         char* msg_table = get_table_name_from_number(sel_item->use_data->peer_id);
2101         create_buddy_msg_table(msg_table);
2102         int msg_id = insert_current_date_to_table(msg_table);
2103
2104         if (msg_id > 0) {
2105                 // send request to service
2106                 Evas_Object *message = NULL;
2107                 tg_message_s* msg = get_message_from_message_table(msg_id, msg_table);
2108
2109                 message = on_message_item_content_get_cb((void *)msg, chat_scroller, "elm.icon.entry");
2110                 elm_object_signal_callback_add(message, "clicked", "item", on_text_message_clicked, (void*)msg_id);
2111                 scroller_push_item(chat_scroller, message, 0);
2112
2113                 free_message(&msg);
2114
2115                 ad->is_last_msg_changed = EINA_TRUE;
2116                 ret = EINA_TRUE;
2117         }
2118         if (msg_table)
2119                 free(msg_table);
2120         return ret;
2121 }
2122
2123
2124
2125 static Eina_Bool on_new_text_message_send_cb(void *data)
2126 {
2127         Evas_Object *chat_scroller = data;
2128         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
2129         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
2130         Evas_Object *text_entry = evas_object_data_get(chat_scroller, "text_entry");
2131
2132         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
2133
2134         const char* text_to_send = elm_entry_entry_get(text_entry);
2135         if (!text_to_send || (strlen(text_to_send) == 0))
2136                 return ECORE_CALLBACK_CANCEL;
2137
2138         int unique_id = get_time_stamp_in_macro();
2139         if (unique_id < 0) {
2140                 unique_id = -1 * unique_id;
2141         }
2142         tg_message_s msg;
2143         msg.msg_id = unique_id;
2144         msg.from_id = ad->current_user_data->user_id.id;
2145         msg.date = time(NULL);
2146         msg.flags = 0;
2147         msg.fwd_date = 0;
2148         msg.fwd_from_id = 0;
2149         msg.fwd_from_id = 0;
2150         msg.unique_id = 0;
2151         msg.message = (char*)text_to_send;
2152         msg.message_len = strlen(text_to_send);
2153         msg.media_type = tgl_message_media_none;
2154         msg.media_id = "";
2155         msg.out = 1;
2156         msg.service = 0;
2157         msg.to_id = sel_item->use_data->peer_id;
2158         msg.unread = 0;
2159         msg.msg_state = TG_MESSAGE_STATE_SENDING;
2160         msg.is_marked_for_delete = 0;
2161         char* msg_table = get_table_name_from_number(msg.to_id);
2162         create_buddy_msg_table(msg_table);
2163         insert_msg_into_db(&msg, msg_table, unique_id);
2164         free(msg_table);
2165
2166         peer_with_pic_s* pic_peer_item = ad->peer_in_cahtting_data;
2167         if (pic_peer_item) {
2168                 tg_peer_info_s* peer_item = pic_peer_item->use_data;
2169                 // update peer table
2170                 if (peer_item) {
2171                         peer_item->last_msg_id = msg.msg_id;
2172                         peer_item->last_msg_date =  msg.date;
2173                         insert_or_update_peer_into_database(peer_item);
2174                 }
2175         }
2176
2177         // send request to service
2178         send_request_for_message_transport(ad, ad->service_client, sel_item->use_data->peer_id, msg.msg_id, tgl_message_media_none, text_to_send, sel_item->use_data->peer_type);
2179
2180         Evas_Object *message = NULL;
2181
2182         message = on_message_item_content_get_cb((void *)&msg, chat_scroller, "elm.icon.entry");
2183         elm_object_signal_callback_add(message, "clicked", "item", on_text_message_clicked, (void*)unique_id);
2184         scroller_push_item(chat_scroller, message, 0);
2185
2186         elm_entry_entry_set(text_entry, "");
2187         ad->is_last_msg_changed = EINA_TRUE;
2188         return ECORE_CALLBACK_CANCEL;
2189 }
2190
2191 static void on_text_message_send_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
2192 {
2193         Evas_Object* chat_scroller = data;
2194         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
2195         if (!ad) {
2196                 return;
2197         }
2198         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
2199         Evas_Object* text_entry = evas_object_data_get(chat_scroller, "text_entry");
2200         int ret = 1;
2201
2202         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
2203         const char* text_to_send = elm_entry_markup_to_utf8(elm_object_text_get(text_entry));
2204         if (!text_to_send || (strlen(text_to_send) == 0))
2205                 return;
2206
2207         if (add_date_item_to_chat(data)) {
2208                 //ecore_timer_add(2, on_new_text_message_send_cb, chat_scroller);
2209                 //return;
2210                 wait_for(2);
2211         }
2212
2213         int unique_id = get_time_stamp_in_macro();
2214         if (unique_id < 0) {
2215                 unique_id = -1 * unique_id;
2216         }
2217         tg_message_s msg;
2218         msg.msg_id = unique_id;
2219         msg.from_id = ad->current_user_data->user_id.id;
2220         msg.date = time(NULL);
2221         msg.flags = 0;
2222         msg.fwd_date = 0;
2223         msg.fwd_from_id = 0;
2224         msg.fwd_from_id = 0;
2225         msg.unique_id = 0;
2226         msg.message = (char*)text_to_send;
2227         msg.message_len = strlen(text_to_send);
2228         msg.media_type = tgl_message_media_none;
2229         msg.media_id = "";
2230         msg.out = 1;
2231         msg.service = 0;
2232         msg.to_id = sel_item->use_data->peer_id;
2233         msg.unread = 0;
2234         msg.msg_state = TG_MESSAGE_STATE_SENDING;
2235         msg.is_marked_for_delete = 0;
2236         char* msg_table = get_table_name_from_number(msg.to_id);
2237         create_buddy_msg_table(msg_table);
2238         insert_msg_into_db(&msg, msg_table, unique_id);
2239         free(msg_table);
2240
2241         peer_with_pic_s* pic_peer_item = ad->peer_in_cahtting_data;
2242         if (pic_peer_item) {
2243                 tg_peer_info_s* peer_item = pic_peer_item->use_data;
2244                 // update peer table
2245                 if (peer_item) {
2246                         peer_item->last_msg_id = msg.msg_id;
2247                         peer_item->last_msg_date =  msg.date;
2248                         insert_or_update_peer_into_database(peer_item);
2249                 }
2250         }
2251
2252         // send request to service
2253         send_request_for_message_transport(ad, ad->service_client, sel_item->use_data->peer_id, msg.msg_id, tgl_message_media_none, text_to_send, sel_item->use_data->peer_type);
2254
2255         Evas_Object *message = NULL;
2256
2257         Evas_Object *layout = evas_object_data_get(ad->nf, "main_layout");
2258         evas_object_data_set(layout, "is_end_edge", (void *) 1);
2259
2260         message = on_message_item_content_get_cb((void *)&msg, chat_scroller, "elm.icon.entry");
2261         elm_object_signal_callback_add(message, "clicked", "item", on_text_message_clicked, (void*)unique_id);
2262         scroller_push_item(chat_scroller, message, 0);
2263
2264         elm_entry_entry_set(text_entry, "");
2265         ad->is_last_msg_changed = EINA_TRUE;
2266 }
2267
2268 void on_user_status_changed(appdata_s* ad, char* status)
2269 {
2270         if (!ad || !status)
2271                 return;
2272
2273         Elm_Object_Item *nf_it = evas_object_data_get(ad->nf, "navi_item");
2274         char status_str[256] = {0,};
2275         snprintf(status_str, sizeof(status_str) - 1, "%s", status);
2276         elm_object_item_part_text_set(nf_it, "subtitle", status_str);
2277 }
2278
2279 static void compare_with_current_date(int rtime, Elm_Object_Item *nf_it)
2280 {
2281         char time_str[256] = {0,};
2282         time_t local_t = time(NULL);
2283         int diff_sec = 0;
2284         int diff_min = 0;
2285         int diff_hour = 0;
2286         int diff_day = 0;
2287
2288         diff_sec = local_t - rtime;
2289         diff_min = diff_sec / 60;
2290         diff_hour = diff_min / 60;
2291         diff_day = diff_hour / 24;
2292         LOGD("different : day : %d, hour = %d, min = %d, sec = %d", diff_day, diff_hour, diff_min, diff_sec);
2293
2294
2295         if (diff_day > 30) {
2296                 snprintf(time_str, sizeof(time_str) - 1, "%s", i18n_get_text("IDS_TGRAM_HEADER_LAST_SEEN_LONG_TIME_AGO_ABB"));
2297                 goto OUT;
2298         }
2299
2300         if (diff_day > 7) {
2301                 snprintf(time_str, sizeof(time_str) - 1, "%s", i18n_get_text("IDS_TGRAM_HEADER_LAST_SEEN_WITHIN_A_MONTH_ABB"));
2302                 goto OUT;
2303         }
2304         if (diff_day > 1) {
2305                 snprintf(time_str, sizeof(time_str) - 1, "%s", i18n_get_text("IDS_TGRAM_HEADER_LAST_SEEN_WITHIN_A_WEEK_ABB"));
2306                 goto OUT;
2307         }
2308
2309         if (diff_hour > 1) {
2310                 snprintf(time_str, sizeof(time_str) - 1, i18n_get_text("IDS_TGRAM_HEADER_LAST_SEEN_PD_HOURS_AGO_ABB"), diff_hour);
2311                 goto OUT;
2312         }
2313
2314         if (diff_hour == 1) {
2315                 snprintf(time_str, sizeof(time_str) - 1, "%s", i18n_get_text("IDS_TGRAM_HEADER_LAST_SEEN_1_HOUR_AGO_ABB"));
2316                 goto OUT;
2317         }
2318         if (diff_min > 1) {
2319                 snprintf(time_str, sizeof(time_str) - 1, i18n_get_text("IDS_TGRAM_HEADER_LAST_SEEN_PD_MINUTES_AGO_ABB"), diff_min);
2320                 goto OUT;
2321         }
2322         if (diff_min == 1) {
2323                 snprintf(time_str, sizeof(time_str) - 1, "%s", i18n_get_text("IDS_TGRAM_HEADER_LAST_SEEN_1_MINUTE_AGO_ABB"));
2324                 goto OUT;
2325         }
2326         snprintf(time_str, sizeof(time_str) - 1, "%s", i18n_get_text("IDS_TGRAM_HEADER_LAST_SEEN_RECENTLY_ABB"));
2327
2328 OUT:
2329         elm_object_item_part_text_set(nf_it, "subtitle", time_str);
2330 }
2331
2332 void on_user_presence_state_changed(appdata_s* ad, int buddy_id)
2333 {
2334         if (!ad)
2335                 return;
2336         int type_of_chat = ad->peer_in_cahtting_data->use_data->peer_type;
2337         Elm_Object_Item *nf_it = evas_object_data_get(ad->nf, "navi_item");
2338
2339         if (type_of_chat == TGL_PEER_USER) {
2340
2341                 Eina_List* buddy_details_array = get_buddy_info(buddy_id);
2342                 if (buddy_details_array && eina_list_count(buddy_details_array) > 0) {
2343                         Eina_List* buddy_details = eina_list_nth(buddy_details_array, 0);
2344                         if (buddy_details && eina_list_count(buddy_details) > 0) {
2345                                 int* temp_online = (int*)eina_list_nth(buddy_details, 12);
2346                                 int is_online = *temp_online;
2347                                 int* temp_last_seen = (int*)eina_list_nth(buddy_details, 13);
2348                                 int last_seen = *temp_last_seen;
2349
2350                                 if (is_online > 0) {
2351                                         char status_str[256] = {0,};
2352                                         snprintf(status_str, sizeof(status_str) - 1, "%s", i18n_get_text("IDS_TGRAM_SBODY_ONLINE"));
2353                                         elm_object_item_part_text_set(nf_it, "subtitle", status_str);
2354                                 } else {
2355                                         compare_with_current_date(last_seen, nf_it);
2356                                 }
2357
2358                                 for (int i = 0 ; i < eina_list_count(buddy_details_array); i++) {
2359                                         void* val = eina_list_nth(buddy_details, i);
2360                                         free(val);
2361                                 }
2362                                 eina_list_free(buddy_details);
2363                         }
2364                         eina_list_free(buddy_details_array);
2365                 }
2366
2367         } else if (type_of_chat == TGL_PEER_CHAT) {
2368
2369                 tg_chat_info_s* chat_info = get_chat_info(buddy_id);
2370                 if (!chat_info) {
2371                         char status_str[256] = {0,};
2372                         snprintf(status_str, sizeof(status_str) - 1, "Unidentified.");
2373                         elm_object_item_part_text_set(nf_it, "subtitle", status_str);
2374                         return;
2375                 }
2376
2377                 int user_list_size = chat_info->user_list_size;
2378                 int online_members = 0;
2379
2380                 Eina_List *names_of_buddies = NULL;
2381                 names_of_buddies = evas_object_data_get(ad->nf, "names_of_buddies");
2382
2383                 if(names_of_buddies != NULL){
2384                                 buddies_info *buddy = NULL;
2385                                 EINA_LIST_FREE(names_of_buddies, buddy) {
2386                                         if (buddy) {
2387                                                 if(buddy->name) {
2388                                                         free(buddy->name);
2389                                                 }
2390                                         }
2391                                 }
2392                                 names_of_buddies = NULL;
2393                                 evas_object_data_set(ad->nf, "names_of_buddies", NULL);
2394                         }
2395
2396                 for (int i = 0; i < user_list_size; i++) {
2397
2398                         int is_online = get_buddy_online_status(chat_info->chat_users[i]);
2399                         if (is_online > 0) {
2400                                 online_members++;
2401                         }
2402
2403                         char *buddy_full_name = NULL;
2404                         int buddy_id = chat_info->chat_users[i];
2405
2406                         if (buddy_id == ad->current_user_data->user_id.id) {
2407                                 buddy_full_name = strdup(ad->current_user_data->print_name);
2408                         } else {
2409                                 buddy_full_name = get_buddy_name_from_id(buddy_id);
2410                         }
2411
2412                         if (buddy_full_name) {
2413                                 char *buddy_name =  replace(buddy_full_name, '_', " ");
2414                                 if (buddy_name) {
2415                                         buddies_info *buddy_info = (buddies_info*)malloc(sizeof(buddies_info));
2416                                         buddy_info->name = buddy_name;
2417                                         buddy_info->id = buddy_id;
2418                                         names_of_buddies = eina_list_append(names_of_buddies, (void*)(buddy_info));
2419                                 }
2420                                 free(buddy_full_name);
2421                         }
2422                 }
2423
2424                 evas_object_data_set(ad->nf, "names_of_buddies", (void*)names_of_buddies);
2425
2426 #if 0
2427                 if (online_members == 0) {
2428                         char status_str[256] = {0,};
2429                         snprintf(status_str, sizeof(status_str) - 1, "<font=Tizen:style=Bold color=#ffffff align=left><font_size=30>%d %s</font_size></font>", user_list_size, i18n_get_text("IDS_TGRAM_BODY_PD_PARTICIPANTS"));
2430                         elm_object_item_part_text_set(nf_it, "subtitle", status_str);
2431                 } else {
2432                         char status_str[256] = {0,};
2433                         snprintf(status_str, sizeof(status_str) - 1, "<font=Tizen:style=Bold color=#ffffff align=left><font_size=30>%d %s, %d %s</font_size></font>", user_list_size, , online_members, i18n_get_text("IDS_TGRAM_SBODY_ONLINE"));
2434                         elm_object_item_part_text_set(nf_it, "subtitle", status_str);
2435                 }
2436 #else
2437                 char status_str[256] = {0,};
2438                 snprintf(status_str, sizeof(status_str) - 1, i18n_get_text("IDS_TGRAM_BODY_PD_PARTICIPANTS"), user_list_size);
2439
2440                 char temp_status_str[512] = {0,};
2441                 snprintf(temp_status_str, sizeof(temp_status_str) - 1, "%s", status_str);
2442
2443                 elm_object_item_part_text_set(nf_it, "subtitle", temp_status_str);
2444 #endif
2445
2446                 if (chat_info) {
2447                         if (chat_info->print_title) {
2448                                 free(chat_info->print_title);
2449                                 chat_info->print_title = NULL;
2450                         }
2451                         if (chat_info->photo_path) {
2452                                 free(chat_info->photo_path);
2453                                 chat_info->photo_path = NULL;
2454                         }
2455                         if (chat_info->title) {
2456                                 free(chat_info->title);
2457                                 chat_info->title = NULL;
2458                         }
2459
2460                 }
2461         }
2462 }
2463
2464 static Eina_Bool on_change_input_type_requested(void *data)
2465 {
2466         Evas_Object* text_entry = data;
2467         if (!text_entry) {
2468                 LOGE("Fail to get the text_entry");
2469                 return ECORE_CALLBACK_CANCEL;
2470         }
2471         elm_object_focus_set(text_entry, EINA_TRUE);
2472         elm_entry_input_panel_layout_set(text_entry, ELM_INPUT_PANEL_LAYOUT_EMOTICON);
2473         elm_entry_input_panel_show(text_entry);
2474
2475         return ECORE_CALLBACK_CANCEL;
2476 }
2477
2478 static void on_message_cancel_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
2479 {
2480         Evas_Object *layout = data;
2481         if (!layout) {
2482                 LOGE("Fail to get the layout");
2483                 return;
2484         }
2485         elm_object_signal_emit(layout, "hide", "bubblemessage");
2486 }
2487
2488 static void on_message_smiley_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
2489 {
2490         Evas_Object* text_entry = data;
2491         if (!text_entry) {
2492                 LOGE("Fail to get the text_entry");
2493                 return;
2494         }
2495         ecore_timer_add(0.3, on_change_input_type_requested, text_entry);
2496 }
2497
2498 static void on_message_text_entry_clicked(void *data, Evas_Object *obj, void *event_info)
2499 {
2500         if (!obj) {
2501                 LOGE("Fail to get the entry");
2502                 return;
2503         }
2504         /* This Api is needed for type of keyboard: emoticon or caractor */
2505         elm_entry_input_panel_layout_set(obj, ELM_INPUT_PANEL_LAYOUT_NORMAL);
2506 }
2507
2508 static void on_message_text_entry_changed(void *data, Evas_Object *obj, void *event_info)
2509 {
2510         Evas_Object *layout = data;
2511
2512         if (!layout) {
2513                 LOGE("Fail to get the entry layout");
2514                 return;
2515         }
2516         int attach_show = (int) evas_object_data_get(layout, "is_attach_show");
2517
2518         if (elm_entry_is_empty(obj)) {
2519                 if (!attach_show) {
2520                         elm_object_signal_emit(layout, "show", "attach_btn");
2521                         evas_object_data_set(layout, "is_attach_show", (void *) 1);
2522                 }
2523         } else {
2524                 if (attach_show) {
2525                         elm_object_signal_emit(layout, "hide", "attach_btn");
2526                         evas_object_data_set(layout, "is_attach_show", (void *) 0);
2527                 }
2528         }
2529 }
2530
2531 Evas_Object* create_chat_genlist(Evas_Object *win)
2532 {
2533     Evas_Object *genlist;
2534     Elm_Theme *theme = elm_theme_new();
2535         char edj_path[PATH_MAX] = {0, };
2536         app_get_resource(TELEGRAM_GENLIST_THEME_EDJ, edj_path, (int)PATH_MAX);
2537         elm_theme_extension_add(theme, edj_path);
2538     genlist = elm_genlist_add(win);
2539     elm_object_theme_set(genlist, theme);
2540     elm_object_style_set(genlist, "telegram/default");
2541     evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2542     elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
2543     return genlist;
2544 }
2545
2546 void on_list_media_item_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
2547 {
2548
2549 }
2550
2551 static Eina_Bool on_new_contact_message_send_cb(void *data)
2552 {
2553         Evas_Object *chat_scroller = data;
2554         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
2555         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
2556
2557         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
2558
2559         int unique_id = time(NULL);
2560
2561         char unique_id_str[50];
2562         sprintf(unique_id_str, "%d", unique_id);
2563
2564         tg_message_s msg;
2565         msg.msg_id = unique_id;
2566         msg.from_id = ad->current_user_data->user_id.id;
2567         msg.date = time(NULL);
2568         msg.flags = 0;
2569         msg.fwd_date = 0;
2570         msg.fwd_from_id = 0;
2571         msg.fwd_from_id = 0;
2572         msg.unique_id = unique_id;
2573         msg.message = "";
2574         msg.message_len = 0;
2575         msg.media_type = tgl_message_media_contact;
2576         msg.media_id = strdup(unique_id_str);
2577         msg.out = 1;
2578         msg.service = 0;
2579         msg.to_id = sel_item->use_data->peer_id;
2580         msg.unread = 0;
2581         msg.msg_state = TG_MESSAGE_STATE_SENDING;
2582         msg.is_marked_for_delete = 0;
2583
2584         char* msg_table = get_table_name_from_number(msg.to_id);
2585         create_buddy_msg_table(msg_table);
2586         insert_msg_into_db(&msg, msg_table, unique_id);
2587         int img_width = 0;
2588         int img_height = 0;
2589         int media_size = 0;
2590
2591         char *first_name = evas_object_data_get(chat_scroller, "contact_first_name");
2592         char *last_name = evas_object_data_get(chat_scroller, "contact_last_name");
2593         char *phone_number = evas_object_data_get(chat_scroller, "contact_phone_number");
2594
2595         insert_media_info_to_db(&msg, NULL, img_width, img_height, media_size, NULL, NULL, first_name, last_name, phone_number);
2596
2597         free(msg_table);
2598
2599         // send request to service
2600         send_request_for_media_transport(ad, ad->service_client, sel_item->use_data->peer_id, msg.msg_id, unique_id, tgl_message_media_contact, NULL, sel_item->use_data->peer_type);
2601
2602         Evas_Object *message = NULL;
2603
2604         message = on_message_item_content_get_cb((void *)&msg, chat_scroller, "elm.icon.entry");
2605         elm_object_signal_callback_add(message, "clicked", "item", on_list_media_item_clicked, (void*)unique_id);
2606         scroller_push_item(chat_scroller, message, 0);
2607
2608         free(msg.media_id);
2609
2610         return ECORE_CALLBACK_CANCEL;
2611
2612 }
2613
2614 void send_contact_message_to_buddy(void *data, char *first_name, char *last_name, char *phone_number)
2615 {
2616         Evas_Object *chat_scroller = data;
2617         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
2618         if (!ad) {
2619                 return;
2620         }
2621         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
2622
2623         if (add_date_item_to_chat(data)) {
2624 /*              evas_object_data_set(chat_scroller, "contact_first_name", strdup(first_name));
2625                 evas_object_data_set(chat_scroller, "contact_last_name", strdup(last_name));
2626                 evas_object_data_set(chat_scroller, "contact_phone_number", strdup(phone_number));
2627
2628                 ecore_timer_add(2, on_new_contact_message_send_cb, chat_scroller);
2629                 return;*/
2630                 wait_for(2);
2631         }
2632
2633         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
2634
2635         int unique_id = get_time_stamp_in_macro();
2636         if (unique_id < 0) {
2637                 unique_id = -1 * unique_id;
2638         }
2639         char unique_id_str[50];
2640         sprintf(unique_id_str, "%d", unique_id);
2641
2642         tg_message_s msg;
2643         msg.msg_id = unique_id;
2644         msg.from_id = ad->current_user_data->user_id.id;
2645         msg.date = time(NULL);
2646         msg.flags = 0;
2647         msg.fwd_date = 0;
2648         msg.fwd_from_id = 0;
2649         msg.fwd_from_id = 0;
2650         msg.unique_id = unique_id;
2651         msg.message = "";
2652         msg.message_len = 0;
2653         msg.media_type = tgl_message_media_contact;
2654         msg.media_id = strdup(unique_id_str);
2655         msg.out = 1;
2656         msg.service = 0;
2657         msg.to_id = sel_item->use_data->peer_id;
2658         msg.unread = 0;
2659         msg.msg_state = TG_MESSAGE_STATE_SENDING;
2660         msg.is_marked_for_delete = 0;
2661
2662         char* msg_table = get_table_name_from_number(msg.to_id);
2663         create_buddy_msg_table(msg_table);
2664         insert_msg_into_db(&msg, msg_table, unique_id);
2665         int img_width = 0;
2666         int img_height = 0;
2667         int media_size = 0;
2668         insert_media_info_to_db(&msg, NULL, img_width, img_height, media_size, NULL, NULL, first_name, last_name, phone_number);
2669
2670         free(msg_table);
2671
2672         // send request to service
2673         send_request_for_media_transport(ad, ad->service_client, sel_item->use_data->peer_id, msg.msg_id, unique_id, tgl_message_media_contact, NULL, sel_item->use_data->peer_type);
2674
2675         Evas_Object *message = NULL;
2676
2677         message = on_message_item_content_get_cb((void *)&msg, chat_scroller, "elm.icon.entry");
2678         elm_object_signal_callback_add(message, "clicked", "item", on_list_media_item_clicked, (void*)unique_id);
2679         scroller_push_item(chat_scroller, message, 0);
2680         free(msg.media_id);
2681 }
2682
2683 static Eina_Bool on_new_location_message_send_cb(void *data)
2684 {
2685         Evas_Object *chat_scroller = data;
2686         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
2687         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
2688
2689         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
2690
2691         int unique_id = time(NULL);
2692
2693         char unique_id_str[50];
2694         sprintf(unique_id_str, "%d", unique_id);
2695
2696         tg_message_s msg;
2697         msg.msg_id = unique_id;
2698         msg.from_id = ad->current_user_data->user_id.id;
2699         msg.date = time(NULL);
2700         msg.flags = 0;
2701         msg.fwd_date = 0;
2702         msg.fwd_from_id = 0;
2703         msg.fwd_from_id = 0;
2704         msg.unique_id = unique_id;
2705         msg.message = "";
2706         msg.message_len = 0;
2707         msg.media_type = tgl_message_media_geo;
2708         msg.media_id = strdup(unique_id_str);
2709         msg.out = 1;
2710         msg.service = 0;
2711         msg.to_id = sel_item->use_data->peer_id;
2712         msg.unread = 0;
2713         msg.msg_state = TG_MESSAGE_STATE_SENDING;
2714         msg.is_marked_for_delete = 0;
2715
2716         char* msg_table = get_table_name_from_number(msg.to_id);
2717         create_buddy_msg_table(msg_table);
2718         insert_msg_into_db(&msg, msg_table, unique_id);
2719         int img_width = 0;
2720         int img_height = 0;
2721         int media_size = 0;
2722
2723         char *latitude = evas_object_data_get(chat_scroller, "contact_latitude");
2724         char *longitude = evas_object_data_get(chat_scroller, "contact_longitude");
2725
2726         insert_media_info_to_db(&msg, NULL, img_width, img_height, media_size, latitude, longitude, NULL, NULL, NULL);
2727
2728         free(msg_table);
2729
2730         // send request to service
2731         send_request_for_media_transport(ad, ad->service_client, sel_item->use_data->peer_id, msg.msg_id, unique_id, tgl_message_media_geo, NULL, sel_item->use_data->peer_type);
2732
2733         Evas_Object *message = NULL;
2734
2735         message = on_message_item_content_get_cb((void *)&msg, chat_scroller, "elm.icon.entry");
2736         elm_object_signal_callback_add(message, "clicked", "item", on_list_media_item_clicked, (void*)unique_id);
2737         scroller_push_item(chat_scroller, message, 0);
2738
2739         free(msg.media_id);
2740         return ECORE_CALLBACK_CANCEL;
2741 }
2742
2743 void send_location_message_to_buddy(void *data, char *latitude, char *longitude)
2744 {
2745         Evas_Object *chat_scroller = data;
2746         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
2747         if (!ad) {
2748                 return;
2749         }
2750         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
2751
2752         if (add_date_item_to_chat(data)) {
2753 /*              evas_object_data_set(chat_scroller, "contact_latitude", strdup(latitude));
2754                 evas_object_data_set(chat_scroller, "contact_longitude", strdup(longitude));
2755                 ecore_timer_add(2, on_new_location_message_send_cb, chat_scroller);
2756                 return;*/
2757                 wait_for(2);
2758         }
2759
2760         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
2761
2762         int unique_id = get_time_stamp_in_macro();
2763         if (unique_id < 0) {
2764                 unique_id = -1 * unique_id;
2765         }
2766         char unique_id_str[50];
2767         sprintf(unique_id_str, "%d", unique_id);
2768
2769         tg_message_s msg;
2770         msg.msg_id = unique_id;
2771         msg.from_id = ad->current_user_data->user_id.id;
2772         msg.date = time(NULL);
2773         msg.flags = 0;
2774         msg.fwd_date = 0;
2775         msg.fwd_from_id = 0;
2776         msg.fwd_from_id = 0;
2777         msg.unique_id = unique_id;
2778         msg.message = "";
2779         msg.message_len = 0;
2780         msg.media_type = tgl_message_media_geo;
2781         msg.media_id = strdup(unique_id_str);
2782         msg.out = 1;
2783         msg.service = 0;
2784         msg.to_id = sel_item->use_data->peer_id;
2785         msg.unread = 0;
2786         msg.msg_state = TG_MESSAGE_STATE_SENDING;
2787         msg.is_marked_for_delete = 0;
2788
2789         char* msg_table = get_table_name_from_number(msg.to_id);
2790         create_buddy_msg_table(msg_table);
2791         insert_msg_into_db(&msg, msg_table, unique_id);
2792         int img_width = 0;
2793         int img_height = 0;
2794         int media_size = 0;
2795         insert_media_info_to_db(&msg, NULL, img_width, img_height, media_size, latitude, longitude, NULL, NULL, NULL);
2796
2797         free(msg_table);
2798
2799         // send request to service
2800         send_request_for_media_transport(ad, ad->service_client, sel_item->use_data->peer_id, msg.msg_id, unique_id, tgl_message_media_geo, NULL, sel_item->use_data->peer_type);
2801
2802         Evas_Object *message = NULL;
2803
2804         message = on_message_item_content_get_cb((void *)&msg, chat_scroller, "elm.icon.entry");
2805         elm_object_signal_callback_add(message, "clicked", "item", on_list_media_item_clicked, (void*)unique_id);
2806         scroller_push_item(chat_scroller, message, 0);
2807
2808         free(msg.media_id);
2809 }
2810
2811 static Eina_Bool on_new_media_message_send_cb(void *data)
2812 {
2813         Evas_Object *chat_scroller = data;
2814         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
2815         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
2816
2817         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
2818
2819         int unique_id = time(NULL);
2820
2821         char unique_id_str[50];
2822         sprintf(unique_id_str, "%d", unique_id);
2823
2824         char *file_type_char = evas_object_data_get(chat_scroller, "file_type");
2825         int file_type = atoi(file_type_char);
2826         char *file_path = evas_object_data_get(chat_scroller, "file_path");
2827
2828         tg_message_s msg;
2829         msg.msg_id = unique_id;
2830         msg.from_id = ad->current_user_data->user_id.id;
2831         msg.date = time(NULL);
2832         msg.flags = 0;
2833         msg.fwd_date = 0;
2834         msg.fwd_from_id = 0;
2835         msg.fwd_from_id = 0;
2836         msg.unique_id = unique_id;
2837         msg.message = "";
2838         msg.message_len = 0;
2839         msg.media_type = file_type;
2840         msg.media_id = strdup(unique_id_str);
2841         msg.out = 1;
2842         msg.service = 0;
2843         msg.to_id = sel_item->use_data->peer_id;
2844         msg.unread = 0;
2845         msg.msg_state = TG_MESSAGE_STATE_SENDING;
2846         msg.is_marked_for_delete = 0;
2847
2848         char* msg_table = get_table_name_from_number(msg.to_id);
2849         create_buddy_msg_table(msg_table);
2850         insert_msg_into_db(&msg, msg_table, unique_id);
2851         int img_width = 0;
2852         int img_height = 0;
2853         int media_size = 0;
2854         if (file_type == tgl_message_media_photo) {
2855                 Evas_Object *img = create_image_object_from_file(file_path, chat_scroller);
2856                 elm_image_object_size_get(img, &img_width, &img_height);
2857                 struct stat st;
2858                 stat(file_path, &st);
2859                 media_size = st.st_size;
2860                 evas_object_del(img);
2861         }
2862
2863         insert_media_info_to_db(&msg, (char*)file_path, img_width, img_height, media_size, NULL, NULL , NULL, NULL, NULL);
2864
2865         free(msg_table);
2866
2867         // send request to service
2868         send_request_for_media_transport(ad, ad->service_client, sel_item->use_data->peer_id, msg.msg_id, unique_id, file_type, file_path, sel_item->use_data->peer_type);
2869
2870         Evas_Object *message = NULL;
2871
2872         message = on_message_item_content_get_cb((void *)&msg, chat_scroller, "elm.icon.entry");
2873         elm_object_signal_callback_add(message, "clicked", "item", on_list_media_item_clicked, (void*)unique_id);
2874         scroller_push_item(chat_scroller, message, 0);
2875
2876         free(msg.media_id);
2877         ad->is_last_msg_changed = EINA_TRUE;
2878         return ECORE_CALLBACK_CANCEL;
2879 }
2880
2881 void send_media_message_to_buddy(void *data, const char* file_path, enum tgl_message_media_type file_type)
2882 {
2883         Evas_Object *chat_scroller = data;
2884         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
2885         if (!ad) {
2886                 return;
2887         }
2888         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
2889         if (add_date_item_to_chat(data)) {
2890 /*              int temp_file_type = file_type;
2891                 char file_type_char[10]= {0, };
2892                 sprintf(file_type_char, "%d", temp_file_type);
2893                 evas_object_data_set(chat_scroller, "file_type", strdup(file_type_char));
2894                 evas_object_data_set(chat_scroller, "file_path", strdup(file_path));
2895
2896                 ecore_timer_add(2, on_new_media_message_send_cb, chat_scroller);
2897                 return;*/
2898                 wait_for(2);
2899         }
2900         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
2901
2902         int unique_id = get_time_stamp_in_macro();
2903         if (unique_id < 0) {
2904                 unique_id = -1 * unique_id;
2905         }
2906         char unique_id_str[50];
2907         sprintf(unique_id_str, "%d", unique_id);
2908
2909         tg_message_s msg;
2910         msg.msg_id = unique_id;
2911         msg.from_id = ad->current_user_data->user_id.id;
2912         msg.date = time(NULL);
2913         msg.flags = 0;
2914         msg.fwd_date = 0;
2915         msg.fwd_from_id = 0;
2916         msg.fwd_from_id = 0;
2917         msg.unique_id = unique_id;
2918         msg.message = "";
2919         msg.message_len = 0;
2920         msg.media_type = file_type;
2921         msg.media_id = strdup(unique_id_str);
2922         msg.out = 1;
2923         msg.service = 0;
2924         msg.to_id = sel_item->use_data->peer_id;
2925         msg.unread = 0;
2926         msg.msg_state = TG_MESSAGE_STATE_SENDING;
2927         msg.is_marked_for_delete = 0;
2928
2929         char* msg_table = get_table_name_from_number(msg.to_id);
2930         create_buddy_msg_table(msg_table);
2931         insert_msg_into_db(&msg, msg_table, unique_id);
2932         int img_width = 0;
2933         int img_height = 0;
2934         int media_size = 0;
2935         if (file_type == tgl_message_media_photo) {
2936                 Evas_Object* img = create_image_object_from_file(file_path, chat_scroller);
2937                 elm_image_object_size_get(img, &img_width, &img_height);
2938                 struct stat st;
2939                 stat(file_path, &st);
2940                 media_size = st.st_size;
2941                 evas_object_del(img);
2942         }
2943
2944         insert_media_info_to_db(&msg, (char*)file_path, img_width, img_height, media_size, NULL, NULL , NULL, NULL, NULL);
2945
2946         free(msg_table);
2947
2948         // send request to service
2949         send_request_for_media_transport(ad, ad->service_client, sel_item->use_data->peer_id, msg.msg_id, unique_id, file_type, file_path, sel_item->use_data->peer_type);
2950
2951         Evas_Object *message = NULL;
2952
2953         message = on_message_item_content_get_cb((void *)&msg, chat_scroller, "elm.icon.entry");
2954         elm_object_signal_callback_add(message, "clicked", "item", on_list_media_item_clicked, (void*)unique_id);
2955         scroller_push_item(chat_scroller, message, 0);
2956
2957         free(msg.media_id);
2958         ad->is_last_msg_changed = EINA_TRUE;
2959 }
2960
2961 static Eina_Bool on_timer_expired(void *data)
2962 {
2963         Evas_Object *scroller = data;
2964         int ret = 1;
2965         int is_end_edge_top = 0;
2966         is_end_edge_top = (int)evas_object_data_get(scroller, "is_end_edge_top");
2967
2968         if (!scroller) {
2969                 LOGE("Cannot get the scroller");
2970                 return ECORE_CALLBACK_CANCEL;
2971         }
2972         //ret = scroller_show_bottom_edge(scroller);
2973         ret = scroller_show_previous_region(scroller);
2974         if (!ret) {
2975                 LOGE("Fail to show the bottom of scroller");
2976         }
2977
2978         return ECORE_CALLBACK_CANCEL;
2979 }
2980
2981 Eina_Bool load_chat_history(Evas_Object *chat_scroller)
2982 {
2983         int offset_num = (int)evas_object_data_get(chat_scroller,"offset_num");
2984         if(offset_num < -TG_DBMGR_LIMITED) return EINA_FALSE;
2985         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
2986         int user_id = (int)evas_object_data_get(chat_scroller, "user_id");
2987
2988         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
2989         int buddy_id = sel_item->use_data->peer_id;
2990         char* tablename = get_table_name_from_number(buddy_id);
2991         Eina_List *vals = NULL;
2992         if(offset_num >= 0)
2993                 vals = get_messages_from_message_table_order_by(tablename, MESSAGE_INFO_TABLE_DATE, EINA_TRUE, TG_DBMGR_LIMITED, offset_num);
2994         else
2995                 vals = get_messages_from_message_table_order_by(tablename, MESSAGE_INFO_TABLE_DATE, EINA_TRUE, TG_DBMGR_LIMITED + offset_num, 0);
2996         tg_message_s *message_item = NULL;
2997
2998         if (!vals) {
2999                 // set no messages yet
3000                 return EINA_FALSE;
3001         } else {
3002                 int row_count = eina_list_count(vals);
3003
3004                 for (int i = row_count-1 ; i >= 0 ; i--) {
3005                         Evas_Object *message = NULL;
3006
3007                         message_item = eina_list_nth(vals, i);
3008                         message = on_message_item_content_get_cb((void *)message_item, chat_scroller, "elm.icon.entry");
3009                         elm_object_signal_callback_add(message, "clicked", "item", on_list_media_item_clicked, (void*)message_item->msg_id);
3010                         scroller_push_item(chat_scroller, message, 1);
3011                         free_message(&message_item);
3012                 }
3013                 eina_list_free(vals);
3014         }
3015
3016 //      Ecore_Timer *timer = NULL;
3017 //      timer = ecore_timer_add(0.1, on_timer_expired, chat_scroller);
3018
3019         free(tablename);
3020         evas_object_data_set(chat_scroller, "offset_num", (void *)(offset_num-TG_DBMGR_LIMITED));
3021         return EINA_TRUE;
3022 }
3023
3024
3025
3026 void on_gallery_app_control_reply_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *user_data)
3027 {
3028         if (result == APP_CONTROL_RESULT_SUCCEEDED) {
3029                 Evas_Object* chat_scroller = user_data;
3030                 char* file_path = NULL;
3031                 char** path_arryay = NULL;
3032                 int array_length = 0;
3033                 int status;
3034                 char* mime_type = NULL;
3035                 appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
3036
3037                 status = app_control_get_extra_data_array(reply, APP_CONTROL_DATA_SELECTED, &path_arryay,  &array_length);
3038                 if (status != APP_CONTROL_ERROR_NONE) {
3039                         status = app_control_get_extra_data_array(reply, APP_CONTROL_DATA_PATH, &path_arryay,  &array_length);
3040                         if (status != APP_CONTROL_ERROR_NONE) {
3041                                 if (ad) {
3042                                         show_toast(ad, "Unable to get the result from attach panel");
3043                                 }
3044                                 return;
3045                         }
3046                 }
3047
3048                 status = app_control_get_mime(reply, &mime_type);
3049                 if (status != APP_CONTROL_ERROR_NONE) {
3050                         if (ad) {
3051                                 show_toast(ad, "Unable to get the mime type from attach panel");
3052                         }
3053                         return;
3054                 }
3055
3056                 for (int i = 0 ; i < array_length ; i++) {
3057                         file_path = strdup(path_arryay[i]);
3058                         send_media_message_to_buddy(chat_scroller, file_path, tgl_message_media_photo);
3059                         free(file_path);
3060                         //break;
3061                 }
3062         }
3063 }
3064
3065 void on_location_app_control_reply_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *user_data)
3066 {
3067         Evas_Object* chat_scroller = user_data;
3068         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
3069         if (result == APP_CONTROL_RESULT_SUCCEEDED) {
3070                 char *latitude = NULL;
3071                 char *longitude = NULL;
3072                 app_control_get_extra_data(reply, "latitude", &latitude);
3073                 app_control_get_extra_data(reply, "longitude", &longitude);
3074
3075                 if (latitude && longitude) {
3076                         send_location_message_to_buddy(chat_scroller, latitude, longitude);
3077                 } else {
3078                         //send_location_message_to_buddy(chat_scroller, "0.00000000000", "0.00000000000");
3079                         show_toast(ad, "Unable to detect location values.");
3080                 }
3081         } else {
3082                 show_toast(ad, "Device does not support location feature.");
3083         }
3084 }
3085
3086 void on_video_app_control_reply_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *user_data)
3087 {
3088         if (result == APP_CONTROL_RESULT_SUCCEEDED) {
3089
3090                 Evas_Object* chat_scroller = user_data;
3091                 char* file_path = NULL;
3092                 char** path_arryay = NULL;
3093                 int array_length = 0;
3094                 int status;
3095                 char* mime_type = NULL;
3096                 appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
3097
3098                 status = app_control_get_extra_data_array(reply, APP_CONTROL_DATA_SELECTED, &path_arryay,  &array_length);
3099                 if (status != APP_CONTROL_ERROR_NONE) {
3100                         status = app_control_get_extra_data_array(reply, APP_CONTROL_DATA_PATH, &path_arryay,  &array_length);
3101                         if (status != APP_CONTROL_ERROR_NONE) {
3102                                 if (ad) {
3103                                         show_toast(ad, "Unable to get the result from attach panel");
3104                                 }
3105                                 return;
3106                         }
3107                 }
3108
3109                 status = app_control_get_mime(reply, &mime_type);
3110                 if (status != APP_CONTROL_ERROR_NONE) {
3111                         if (ad) {
3112                                 show_toast(ad, "Unable to get the mime type from attach panel");
3113                         }
3114                         return;
3115                 }
3116                 for (int i = 0 ; i < array_length ; i++) {
3117                         file_path = strdup(path_arryay[i]);
3118                         send_media_message_to_buddy(chat_scroller, file_path, tgl_message_media_document);
3119                         free(file_path);
3120                         //break;
3121                 }
3122         }
3123 }
3124
3125 void on_file_app_control_reply_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *user_data)
3126 {
3127         if (result == APP_CONTROL_RESULT_SUCCEEDED) {
3128
3129                 Evas_Object* chat_scroller = user_data;
3130                 appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
3131                 char* file_path = NULL;
3132                 char** path_arryay = NULL;
3133                 int array_length = 0;
3134                 app_control_get_extra_data_array(reply, APP_CONTROL_DATA_SELECTED, &path_arryay,  &array_length);
3135
3136                 for (int i = 0 ; i < array_length ; i++) {
3137                         file_path = strdup(path_arryay[i]);
3138
3139                         // get mime type of the file
3140
3141                         char *mime_type = NULL;
3142                         if (file_path) {
3143                                 char *extn = strrchr(file_path, '.');
3144                                 if (extn) {
3145                                         extn = replace(extn, '.', "");
3146                                 }
3147                                 if (extn) {
3148                                         mime_type_get_mime_type(extn, &mime_type);
3149                                 }
3150                         }
3151                         if (mime_type) {
3152                                 if (strstr(mime_type, "video") != NULL) {
3153                                         send_media_message_to_buddy(chat_scroller, file_path, tgl_message_media_document);
3154                                 } else if (strstr(mime_type, "audio") != NULL) {
3155                                         send_media_message_to_buddy(chat_scroller, file_path, tgl_message_media_document);
3156                                 } else if (strstr(mime_type, "image") != NULL) {
3157                                         send_media_message_to_buddy(chat_scroller, file_path, tgl_message_media_photo);
3158                                 } else {
3159                                         show_toast(ad, "Unsupported file.");
3160                                 }
3161                         } else {
3162                                 show_toast(ad, "Unsupported file.");
3163                         }
3164                         free(file_path);
3165                         break;
3166                 }
3167         }
3168 }
3169
3170 static void on_voice_record_reply_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *user_data)
3171 {
3172         if (result == APP_CONTROL_RESULT_SUCCEEDED) {
3173                 Evas_Object* chat_scroller = user_data;
3174
3175                 char* file_path = NULL;
3176                 char** path_arryay = NULL;
3177                 int array_length = 0;
3178                 int status;
3179                 char* mime_type = NULL;
3180                 appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
3181
3182                 status = app_control_get_extra_data_array(reply, APP_CONTROL_DATA_SELECTED, &path_arryay,  &array_length);
3183                 if (status != APP_CONTROL_ERROR_NONE) {
3184                         status = app_control_get_extra_data_array(reply, APP_CONTROL_DATA_PATH, &path_arryay,  &array_length);
3185                         if (status != APP_CONTROL_ERROR_NONE) {
3186                                 if (ad) {
3187                                         show_toast(ad, "Unable to get the result from attach panel");
3188                                 }
3189                                 return;
3190                         }
3191                 }
3192
3193                 status = app_control_get_mime(reply, &mime_type);
3194                 if (status != APP_CONTROL_ERROR_NONE) {
3195                         if (ad) {
3196                                 show_toast(ad, "Unable to get the mime type from attach panel");
3197                         }
3198                         return;
3199                 }
3200
3201                 for (int i = 0 ; i < array_length ; i++) {
3202                         file_path = strdup(path_arryay[i]);
3203                         send_media_message_to_buddy(chat_scroller, file_path, tgl_message_media_document);
3204                         free(file_path);
3205                         //break;
3206                 }
3207         }
3208 }
3209
3210 void on_contact_app_control_reply_cb(app_control_h request, app_control_h reply, app_control_result_e result, void *user_data)
3211 {
3212         if (result == APP_CONTROL_RESULT_SUCCEEDED) {
3213
3214                 Evas_Object* chat_scroller = user_data;
3215                 char *contact_name = NULL;
3216                 char *phone_number = NULL;
3217                 app_control_get_extra_data(reply, "http://tizen.org/appcontrol/data/name", &contact_name);
3218                 app_control_get_extra_data(reply, "http://tizen.org/appcontrol/data/phone", &phone_number);
3219
3220         }
3221 }
3222
3223 static void _result_cb(attach_panel_h attach_panel, attach_panel_content_category_e content_category, app_control_h result, app_control_result_e result_code, void *user_data)
3224 {
3225         switch (content_category) {
3226         case ATTACH_PANEL_CONTENT_CATEGORY_IMAGE:
3227         case ATTACH_PANEL_CONTENT_CATEGORY_CAMERA:
3228                 on_gallery_app_control_reply_cb(NULL, result, result_code, user_data);
3229                 break;
3230         case ATTACH_PANEL_CONTENT_CATEGORY_VIDEO:
3231         case ATTACH_PANEL_CONTENT_CATEGORY_VIDEO_RECORDER:
3232                 on_video_app_control_reply_cb(NULL, result, result_code, user_data);
3233                 break;
3234         case ATTACH_PANEL_CONTENT_CATEGORY_VOICE:
3235                 on_voice_record_reply_cb(NULL, result, result_code, user_data);
3236                 break;
3237         case ATTACH_PANEL_CONTENT_CATEGORY_MYFILES:
3238         case ATTACH_PANEL_CONTENT_CATEGORY_AUDIO:
3239                 on_file_app_control_reply_cb(NULL, result, result_code, user_data);
3240                 break;
3241         case ATTACH_PANEL_CONTENT_CATEGORY_CONTACT:
3242                 on_contact_app_control_reply_cb(NULL, result, result_code, user_data);
3243                 break;
3244         default:
3245                 break;
3246         }
3247         attach_panel_hide(attach_panel);
3248 }
3249
3250 void on_media_type_selected_cb(void *data, Evas_Object *obj, void *event_info)
3251 {
3252         Evas_Object* chat_scroller = data;
3253         appdata_s* ad = evas_object_data_get(chat_scroller, "app_data");
3254         const char *label = elm_object_item_text_get((Elm_Object_Item *) event_info);
3255         if (strcasecmp(label, POPUP_TEXT_TAKE_GALLERY) == 0) {
3256                 app_control_h app_control;
3257                 int ret = app_control_create(&app_control);
3258                 if (ret != APP_CONTROL_ERROR_NONE) {
3259                         show_toast(ad, "Error: Can not load image picker");
3260                         return;
3261                 }
3262
3263                 app_control_set_operation(app_control, APP_CONTROL_OPERATION_PICK);
3264
3265                 app_control_set_mime(app_control, "image/*");
3266                 app_control_add_extra_data(app_control, APP_CONTROL_DATA_SELECTION_MODE, "single");
3267                 app_control_send_launch_request(app_control, &on_gallery_app_control_reply_cb, data);
3268                 app_control_destroy(app_control);
3269         } else if (strcasecmp(label, POPUP_TEXT_TAKE_PHOTO) == 0) {
3270                 app_control_h app_control;
3271                 int ret = app_control_create(&app_control);
3272                 if (ret != APP_CONTROL_ERROR_NONE) {
3273                         show_toast(ad, "Error: Can not load image picker");
3274                         return;
3275                 }
3276                 app_control_set_operation(app_control, APP_CONTROL_OPERATION_CREATE_CONTENT);
3277                 app_control_set_mime(app_control, "image/jpg");
3278                 //app_control_add_extra_data(app_control, "crop", "caller_id");
3279                 app_control_send_launch_request(app_control, &on_gallery_app_control_reply_cb, data);
3280                 app_control_destroy(app_control);
3281         } else if (strcasecmp(label, POPUP_TEXT_TAKE_VIDEO) == 0) {
3282                 app_control_h app_control;
3283                 int ret = app_control_create(&app_control);
3284                 if (ret != APP_CONTROL_ERROR_NONE) {
3285                         show_toast(ad, "Error: Can not load image picker");
3286                         return;
3287                 }
3288
3289                 app_control_set_operation(app_control, APP_CONTROL_OPERATION_CREATE_CONTENT);
3290
3291                 int remain_byte_size = 10485760;
3292                 int request_KB_size = 0;
3293
3294                 if (remain_byte_size >= 1024) {
3295                         request_KB_size = remain_byte_size / 1024;
3296                 } else {
3297                         // TODO: Need to check minimum size for recording
3298                         request_KB_size = 1;
3299                 }
3300
3301                 char recording_size[128] = {0, };
3302                 snprintf(recording_size, sizeof(recording_size), "%d", request_KB_size);
3303                 app_control_set_mime(app_control, "video/3gp");
3304                 app_control_add_extra_data(app_control, "LIMIT", recording_size);
3305                 app_control_add_extra_data(app_control, "RESOLUTION", "VGA");
3306                 app_control_add_extra_data(app_control, "CALLER", "telegram");
3307
3308                 app_control_send_launch_request(app_control, &on_video_app_control_reply_cb, data);
3309                 app_control_destroy(app_control);
3310         } else if (strcasecmp(label, POPUP_TEXT_TAKE_AUDIO) == 0) {
3311
3312                 app_control_h app_control;
3313                 int ret = app_control_create(&app_control);
3314                 if (ret != APP_CONTROL_ERROR_NONE) {
3315                         show_toast(ad, "Error: Can not load image picker");
3316                         return;
3317                 }
3318
3319                 app_control_set_operation(app_control, APP_CONTROL_OPERATION_CREATE_CONTENT);
3320
3321                 int size = 10485760;
3322
3323         int remain_byte_size = (int)size;
3324         int request_KB_size = 0;
3325
3326         if (remain_byte_size >= 1024) {
3327                 request_KB_size = remain_byte_size / 1024;
3328         } else {
3329                 // TODO: Need to check minimum size for recording
3330                 request_KB_size = 1;
3331         }
3332
3333                 char recording_size[128] = {0, };
3334                 snprintf(recording_size, sizeof(recording_size), "%d", request_KB_size);
3335                 app_control_add_extra_data(app_control, "SIZE", recording_size);
3336                 app_control_set_mime(app_control, "audio/*");
3337                 app_control_send_launch_request(app_control, &on_voice_record_reply_cb, data);
3338                 app_control_destroy(app_control);
3339
3340         } else if (strcasecmp(label, POPUP_TEXT_TAKE_FILE) == 0) {
3341                 app_control_h app_control;
3342                 int ret = app_control_create(&app_control);
3343                 if (ret != APP_CONTROL_ERROR_NONE) {
3344                         show_toast(ad, "Error: Can not load image picker");
3345                         return;
3346                 }
3347
3348                 app_control_set_operation(app_control, APP_CONTROL_OPERATION_PICK);
3349
3350                 app_control_set_mime(app_control, "*/*");
3351                 app_control_add_extra_data(app_control, APP_CONTROL_DATA_SELECTION_MODE, "single");
3352                 app_control_send_launch_request(app_control, &on_file_app_control_reply_cb, data);
3353                 app_control_destroy(app_control);
3354
3355         } else if (strcasecmp(label, POPUP_TEXT_TAKE_LOCATION) == 0) {
3356                 app_control_h app_control;
3357                 int ret = app_control_create(&app_control);
3358                 if (ret != APP_CONTROL_ERROR_NONE) {
3359                         show_toast(ad, "Error: Can not load location picker");
3360                         return;
3361                 }
3362                 app_control_set_operation(app_control, APP_CONTROL_OPERATION_PICK);
3363                 //app_control_set_app_id(app_control, "com.here.tizen.maps");
3364                 app_control_set_uri(app_control, "geo");
3365                 app_control_send_launch_request(app_control, &on_location_app_control_reply_cb, data);
3366                 app_control_destroy(app_control);
3367         } else if (strcasecmp(label, POPUP_TEXT_TAKE_CONTACT) == 0) {
3368                 app_control_h app_control;
3369                 int ret = app_control_create(&app_control);
3370                 if (ret != APP_CONTROL_ERROR_NONE) {
3371                         show_toast(ad, "Error: Can not load location picker");
3372                         return;
3373                 }
3374                 app_control_set_operation(app_control, APP_CONTROL_OPERATION_PICK);
3375                 app_control_set_mime(app_control, "application/vnd.tizen.contact");
3376                 app_control_add_extra_data(app_control, APP_CONTROL_DATA_SELECTION_MODE, "single");
3377                 app_control_send_launch_request(app_control, &on_contact_app_control_reply_cb, data);
3378                 app_control_destroy(app_control);
3379         }
3380
3381         evas_object_del(obj);
3382 }
3383
3384
3385 void popup_move_dropdown(Evas_Object *ctxpopup, Evas_Object *btn)
3386 {
3387         Evas_Coord x, y, w , h;
3388         evas_object_geometry_get(btn, &x, &y, &w, &h);
3389         evas_object_move(ctxpopup, x + (w / 2), y + h - 50);
3390 }
3391
3392 void on_media_attach_dismissed_cb(void *data, Evas_Object *obj, void *event_info)
3393 {
3394         evas_object_del(obj);
3395 }
3396
3397 static void on_media_attach_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
3398 {
3399         Evas_Object* chat_scroller = data;
3400         if (!chat_scroller) {
3401                 return;
3402         }
3403         appdata_s *ad = evas_object_data_get(chat_scroller, "app_data");
3404         if (!ad) {
3405                 return;
3406         }
3407         attach_panel_h attach_panel = NULL;
3408         int ret;
3409         bool visible = false;
3410
3411         attach_panel = evas_object_data_get(ad->conform, "attach_panel");
3412         if (attach_panel) {
3413                         if (attach_panel_get_visibility(attach_panel, &visible) != ATTACH_PANEL_ERROR_NONE) {
3414                                 attach_panel_set_result_cb(attach_panel, _result_cb, chat_scroller);
3415                                 return;
3416                         }
3417                         if (!visible) {
3418                                 attach_panel_show(attach_panel);
3419                         }
3420                         attach_panel_set_result_cb(attach_panel, _result_cb, chat_scroller);
3421                         return;
3422                 }
3423
3424         ret = attach_panel_create(ad->conform, &attach_panel);
3425
3426         if (!attach_panel) {
3427                 return;
3428         }
3429         attach_panel_add_content_category(attach_panel, ATTACH_PANEL_CONTENT_CATEGORY_IMAGE, NULL);
3430         attach_panel_add_content_category(attach_panel, ATTACH_PANEL_CONTENT_CATEGORY_CAMERA, NULL);
3431         attach_panel_add_content_category(attach_panel, ATTACH_PANEL_CONTENT_CATEGORY_VOICE, NULL);
3432         attach_panel_add_content_category(attach_panel, ATTACH_PANEL_CONTENT_CATEGORY_VIDEO, NULL);
3433         attach_panel_add_content_category(attach_panel, ATTACH_PANEL_CONTENT_CATEGORY_AUDIO, NULL);
3434         attach_panel_add_content_category(attach_panel, ATTACH_PANEL_CONTENT_CATEGORY_CONTACT, NULL);
3435         attach_panel_add_content_category(attach_panel, ATTACH_PANEL_CONTENT_CATEGORY_MYFILES, NULL);
3436         attach_panel_add_content_category(attach_panel, ATTACH_PANEL_CONTENT_CATEGORY_VIDEO_RECORDER, NULL);
3437         attach_panel_set_result_cb(attach_panel, _result_cb, chat_scroller);
3438
3439         attach_panel_show(attach_panel);
3440         evas_object_data_set(ad->conform, "attach_panel", attach_panel);
3441
3442 }
3443
3444 #if 0
3445 static void on_text_message_send_pressed(void *data, Evas_Object *obj, void *event_info)
3446 {
3447         elm_image_file_set(data, ui_utils_get_resource(SEND_UNPRESSED_ICON), NULL);
3448 }
3449
3450 static void on_text_message_send_unpressed(void *data, Evas_Object *obj, void *event_info)
3451 {
3452         elm_image_file_set(data, ui_utils_get_resource(SEND_PRESSED_ICON), NULL);
3453 }
3454 #endif
3455
3456 void on_message_back_button_clicked(void *data, Evas_Object *obj, void *event_info)
3457 {
3458         appdata_s *ad = data;
3459         if (!ad)
3460                 return;
3461
3462         app_nf_back_cb(data, obj, event_info);
3463 }
3464
3465 void on_user_info_button_clicked(void *data, Evas_Object *obj, void *event_info)
3466 {
3467         appdata_s *ad = data;
3468
3469         peer_with_pic_s  *sel_item = ad->peer_in_cahtting_data;
3470         tg_peer_info_s *user_data = sel_item->use_data;
3471
3472         if (!sel_item || !user_data) {
3473                 show_toast(ad, "Can not display user info");
3474                 return;
3475         }
3476
3477         if (user_data->peer_type == TGL_PEER_USER) {
3478                 launch_user_info_screen(ad, user_data->peer_id);
3479         } else if (user_data->peer_type == TGL_PEER_CHAT) {
3480                 launch_chat_info_screen(ad, user_data->peer_id);
3481         } else {
3482
3483         }
3484 }
3485
3486 void refresh_messaging_view(appdata_s *ad)
3487 {
3488         if (!ad)
3489                 return;
3490
3491         Evas_Object *scroller = evas_object_data_get(ad->nf, "chat_list");
3492
3493                 if (scroller) {
3494                         Evas_Object *box_layout = NULL;
3495                         Evas_Object *box = NULL;
3496                         Eina_List *list = NULL;
3497                         Eina_List *box_list = NULL;
3498                         Evas_Object *last_item = NULL;
3499
3500                         box_layout = elm_object_content_get(scroller);
3501                         if (!box_layout) {
3502                                 LOGE("Fail to get the box into scroller");
3503                                 return;
3504                         }
3505                         list = elm_box_children_get(box_layout);
3506                         if (!list) {
3507                                 LOGE("Fail to get the list into box");
3508                                 return;
3509                         }
3510
3511                         box = eina_list_nth(list, 0);
3512                         if (!box) {
3513                                 LOGE("Fail to get the box into box layout");
3514                                 return;
3515                         }
3516
3517                         box_list = elm_box_children_get(box);
3518                         if (!box_list) {
3519                                 LOGE("Fail to get the box_list into box");
3520                                 return;
3521                         }
3522
3523                         last_item = eina_list_nth(box_list, eina_list_count(box_list)-1);
3524                         if (!last_item) {
3525                                 LOGE("Fail to get the last item into box");
3526                                 return;
3527                         }
3528
3529                         int x, y;
3530                         evas_object_geometry_get(last_item, &x, &y, NULL, NULL);
3531
3532                         elm_scroller_region_show(scroller, x, y, -1, -1);
3533
3534                         eina_list_free(box_list);
3535                         eina_list_free(list);
3536                 }
3537 }
3538
3539 static void click_user_name_cb(void *data, Evas_Object *obj, void *event_info)
3540 {
3541         appdata_s *ad = evas_object_data_get(obj,"app_data");
3542         Elm_Object_Item *item = event_info;
3543         const char *clicked_name = elm_object_item_text_get(item);
3544         int peer_id = (int)elm_object_item_data_get(item);
3545         peer_with_pic_s* prev_peer_in_chatting_data = ad->peer_in_cahtting_data;
3546         user_data_with_pic_s* prev_buddy_in_chatting_data = ad->buddy_in_cahtting_data;
3547
3548         int buddy_list_counts = eina_list_count(ad->buddy_list);
3549         for (int i = 0; i < buddy_list_counts; i++) {
3550                 user_data_with_pic_s *item = eina_list_nth(ad->buddy_list, i);
3551                 user_data_s* user_data = item->use_data;
3552
3553                 if (user_data->user_id.id == peer_id) {
3554                         ad->buddy_in_cahtting_data = item;
3555                         break;
3556                 }
3557         }
3558         int peer_list_counts = eina_list_count(ad->peer_list);
3559         for (int i = 0; i < peer_list_counts; i++) {
3560                 peer_with_pic_s* pic_item = eina_list_nth(ad->peer_list, i);
3561                 tg_peer_info_s* item = pic_item->use_data;
3562                 if (item->peer_id == peer_id) {
3563                         ad->peer_in_cahtting_data = pic_item;
3564                         break;
3565                 }
3566         }
3567
3568         launch_user_info_screen(ad, peer_id);
3569
3570         ad->buddy_in_cahtting_data = prev_buddy_in_chatting_data;
3571         ad->peer_in_cahtting_data = prev_peer_in_chatting_data;
3572 }
3573
3574 static void on_expand_button_clicked(void *data, Evas_Object *obj, void *event_info)
3575 {
3576         Evas_Object *expand_pic = data;
3577         if (!expand_pic)
3578                 return;
3579
3580         appdata_s *ad = evas_object_data_get(expand_pic, "app_data");
3581         Evas_Object *parent_layout = evas_object_data_get(expand_pic, "parent_layout");
3582
3583         Eina_Bool is_expanded = (Eina_Bool)evas_object_data_get(expand_pic, "is_expanded");
3584
3585         if (!is_expanded) {
3586
3587                 elm_image_file_set(expand_pic, ui_utils_get_resource(TG_EXPAND_CLOSE), NULL);
3588
3589                 Evas_Object *grp_names_bg = elm_bg_add(ad->nf);
3590                 evas_object_size_hint_align_set(grp_names_bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
3591                 evas_object_size_hint_weight_set(grp_names_bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3592                 evas_object_color_set(grp_names_bg, 255, 255, 255, 255);
3593             elm_image_resizable_set(grp_names_bg, EINA_TRUE, EINA_TRUE);
3594             elm_image_fill_outside_set(grp_names_bg, EINA_TRUE);
3595             evas_object_show(grp_names_bg);
3596             elm_object_part_content_set(parent_layout, "swallow.group_detail_box,bg", grp_names_bg);
3597
3598             Evas_Object* grp_names_lbl = elm_multibuttonentry_add(ad->nf);
3599
3600             elm_entry_cursor_end_set(grp_names_lbl);
3601                 evas_object_size_hint_weight_set(grp_names_lbl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3602                 evas_object_size_hint_align_set(grp_names_lbl, EVAS_HINT_FILL, EVAS_HINT_FILL);
3603                 elm_entry_single_line_set(grp_names_lbl,  EINA_FALSE);
3604                 elm_entry_scrollable_set(grp_names_lbl, EINA_TRUE);
3605                 elm_entry_cnp_mode_set(grp_names_lbl, ELM_CNP_MODE_NO_IMAGE);
3606                 elm_entry_context_menu_disabled_set(grp_names_lbl, EINA_TRUE);
3607                 elm_object_focus_set(grp_names_lbl, EINA_FALSE);
3608                 elm_multibuttonentry_editable_set(grp_names_lbl, EINA_FALSE);
3609
3610                 evas_object_show(grp_names_lbl);
3611
3612                 evas_object_data_set(grp_names_lbl, "app_data", ad);
3613
3614                 Eina_List *names_of_buddies = NULL;
3615                 names_of_buddies = evas_object_data_get(ad->nf, "names_of_buddies");
3616
3617                 if (names_of_buddies) {
3618                         int buddies_counts = eina_list_count(names_of_buddies);
3619                         buddies_info *buddy_info;
3620                         for(int i = 0 ; i < buddies_counts ; i++){
3621                                 buddy_info = (buddies_info*)eina_list_nth(names_of_buddies,i);
3622                                 if(buddy_info == NULL) continue;
3623                                 int len = strlen(buddy_info->name);
3624                                 char *name_str = (char*)malloc(len + 256);
3625                                 if(name_str){
3626                                         sprintf(name_str, "<font=Tizen:style=Bold align=center><font_size=40>%s</font_size></font>", buddy_info->name);
3627                                         Elm_Object_Item *button_item = elm_multibuttonentry_item_append(grp_names_lbl, name_str, click_user_name_cb, ad);
3628                                         elm_object_item_data_set(button_item, (void*)(buddy_info->id));
3629                                         free(name_str);
3630                                 }
3631                         }
3632                 }
3633
3634                 elm_object_part_content_set(parent_layout, "swallow.group_detail_box", grp_names_lbl);
3635
3636         } else {
3637
3638                 elm_image_file_set(expand_pic, ui_utils_get_resource(TG_EXPAND_OPEN), NULL);
3639
3640                 Evas_Object *grp_names_lbl = elm_object_part_content_get(parent_layout, "swallow.group_detail_box");
3641                 if (grp_names_lbl) {
3642                         evas_object_del(grp_names_lbl);
3643                         grp_names_lbl = NULL;
3644                 }
3645
3646                 Evas_Object *grp_names_bg = elm_object_part_content_get(parent_layout, "swallow.group_detail_box,bg");
3647                 if (grp_names_bg) {
3648                         evas_object_del(grp_names_bg);
3649                         grp_names_bg = NULL;
3650                 }
3651         }
3652         is_expanded = !is_expanded;
3653         evas_object_data_set(expand_pic, "is_expanded", (void *)is_expanded);
3654 }
3655
3656 static Eina_Bool _pop_cb(void *data, Elm_Object_Item *it)
3657 {
3658         appdata_s *ad = data;
3659         attach_panel_h attach_panel = NULL;
3660         if (!ad) {
3661                 LOGE("Failed to get the ad");
3662                 return EINA_FALSE;
3663         }
3664         attach_panel = evas_object_data_get(ad->conform, "attach_panel");
3665         if (attach_panel) {
3666                 attach_panel_hide(attach_panel);
3667         }
3668         Eina_List *names_of_buddies = evas_object_data_get(ad->nf, "names_of_buddies");
3669
3670         buddies_info *buddy = NULL;
3671         EINA_LIST_FREE(names_of_buddies, buddy) {
3672                 if (buddy) {
3673                         free(buddy->name);
3674                 }
3675         }
3676         eina_list_free(names_of_buddies);
3677         evas_object_data_set(ad->nf, "names_of_buddies", NULL);
3678         return EINA_TRUE;
3679 }
3680
3681 static void _edge_cb(void *data, Evas_Object *scroller, void *event_info)
3682 {
3683         Evas_Object *layout = data;
3684         int is_end_edge = 0;
3685         is_end_edge = (int)evas_object_data_get(layout, "is_end_edge");
3686
3687         if (!is_end_edge) {
3688                 elm_object_signal_emit(layout, "hide", "bubblemessage");
3689                 evas_object_data_set(layout, "is_end_edge", (void *) 1);
3690         }
3691 }
3692
3693 static void _edge_top_cb(void *data, Evas_Object *scroller, void *event_info)
3694 {
3695         int is_end_edge_top = 0;
3696         //int offset_num = (int)evas_object_data_get(scroller, "offset_num");
3697         is_end_edge_top = (int)evas_object_data_get(scroller, "is_end_edge_top");
3698
3699         if (!is_end_edge_top) {
3700                 elm_scroller_movement_block_set(scroller,ELM_SCROLLER_MOVEMENT_BLOCK_VERTICAL );
3701                 int prev_h = scroller_previous_region_get(scroller);
3702                 evas_object_data_set(scroller, "previous_h",(void*)prev_h);
3703                 evas_object_data_set(scroller, "is_end_edge_top",(void*)1);
3704                 load_chat_history(scroller);
3705                 elm_scroller_movement_block_set(scroller,ELM_SCROLLER_MOVEMENT_NO_BLOCK);
3706         }
3707 }
3708
3709 static void _scroll_cb(void *data, Evas_Object *scroller, void *event_info)
3710 {
3711         Evas_Object *layout = data;
3712         evas_object_data_set(layout, "is_end_edge", (void *) 0);
3713         evas_object_data_set(scroller, "is_end_edge_top", (void *) 0);
3714 //      evas_object_data_set(layout, "is_end_edge_top", (void *) 0);
3715 }
3716
3717 int get_start_offset_num(char* table_name){
3718         char unknown_str[50];
3719         int unknown = 0;
3720         sprintf(unknown_str, "%d", unknown);
3721
3722         char* where_clause = (char*)malloc(strlen(MESSAGE_INFO_TABLE_MARKED_FOR_DELETE) + strlen(" = ") + strlen(unknown_str) + 1);
3723         sprintf(where_clause, "%s = %s", MESSAGE_INFO_TABLE_MARKED_FOR_DELETE, unknown_str);
3724 /*      strcpy(where_clause, MESSAGE_INFO_TABLE_MARKED_FOR_DELETE);
3725         strcat(where_clause, " = ");
3726         strcat(where_clause, unknown_str);*/
3727         int row_counts = get_number_of_rows(table_name,where_clause);
3728         return (row_counts-TG_DBMGR_LIMITED);
3729 }
3730
3731 static Eina_Bool _load_history_cb(void *data)
3732 {
3733         Evas_Object *nf = data;
3734         if (!nf) {
3735                 LOGE("Fail to get the nf");
3736                 return ECORE_CALLBACK_CANCEL;
3737         }
3738         Evas_Object *scroller = evas_object_data_get(nf, "chat_list");
3739         if (!scroller) {
3740                 LOGE("Fail to get the scroller");
3741                 return ECORE_CALLBACK_CANCEL;
3742         }
3743         Evas_Object *layout = evas_object_data_get(nf, "chat_list_no_msg_text");
3744         if (!layout) {
3745                 LOGE("Fail to get the layout");
3746                 return ECORE_CALLBACK_CANCEL;
3747         }
3748
3749         Eina_Bool ret = load_chat_history(scroller);
3750         if (!ret) {
3751                 LOGD("There is no message in chat room");
3752                 // show no messages
3753                 elm_object_part_text_set(layout, "no_msg_text", i18n_get_text("IDS_TGRAM_BODY_NO_MESSAGES_HERE_YET_ING"));
3754                 elm_object_signal_emit(layout, "show", "message");
3755         }
3756
3757         return ECORE_CALLBACK_CANCEL;
3758 }
3759
3760 void launch_messaging_view_cb(appdata_s* ad, int user_id)
3761 {
3762         if (!ad)
3763                 return;
3764
3765         if (ad->msg_popup) {
3766                 evas_object_del(ad->msg_popup);
3767                 ad->msg_popup = NULL;
3768         }
3769
3770         delete_floating_button(ad);
3771
3772         ad->current_app_state = TG_CHAT_MESSAGING_VIEW_STATE;
3773         ad->is_last_msg_changed = EINA_FALSE;
3774         send_request_for_server_connection_status(ad, ad->service_client);
3775         char edj_path[PATH_MAX] = {0, };
3776         app_get_resource(TELEGRAM_INIT_VIEW_EDJ, edj_path, (int)PATH_MAX);
3777
3778         Evas_Object *layout = elm_layout_add(ad->nf);
3779         elm_layout_file_set(layout, edj_path, "chat_messaging_layout");
3780         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3781         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
3782         evas_object_show(layout);
3783
3784         peer_with_pic_s *sel_item =  eina_list_nth(ad->peer_list, user_id);
3785         if (!sel_item)
3786                 return;
3787
3788         tg_peer_info_s* user = sel_item->use_data;
3789
3790         /*************************** START: message list ************************************/
3791
3792         Evas_Object* msg_box_layout = elm_layout_add(ad->nf);
3793         elm_layout_file_set(msg_box_layout, edj_path, "custom_gen_list");
3794         evas_object_size_hint_weight_set(msg_box_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3795         evas_object_size_hint_align_set(msg_box_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
3796         evas_object_show(msg_box_layout);
3797
3798         Evas_Object *list_bg = elm_image_add(msg_box_layout);
3799         evas_object_size_hint_align_set(list_bg, EVAS_HINT_FILL, EVAS_HINT_FILL);
3800         evas_object_size_hint_weight_set(list_bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3801         if (ad->chat_background) {
3802                 elm_image_file_set(list_bg, ad->chat_background, NULL);
3803         } else {
3804                 //elm_image_file_set(list_bg, ui_utils_get_resource(TG_CHAT_DEFAULT_BG), NULL);
3805         }
3806     elm_image_resizable_set(list_bg, EINA_TRUE, EINA_TRUE);
3807     elm_image_fill_outside_set(list_bg, EINA_TRUE);
3808     evas_object_show(list_bg);
3809
3810     elm_object_part_content_set(msg_box_layout, "swallow.gen_list.bg", list_bg);
3811
3812         Evas_Object *chat_scroller = elm_scroller_add(ad->nf);
3813         evas_object_size_hint_weight_set(chat_scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3814         evas_object_size_hint_align_set(chat_scroller, EVAS_HINT_FILL, 0.0);
3815         elm_scroller_policy_set(chat_scroller, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO);
3816         evas_object_show(chat_scroller);
3817         evas_object_smart_callback_add(chat_scroller, "scroll", _scroll_cb, layout);
3818         /*check_top*/
3819         //evas_object_smart_callback_add(chat_scroller,"scroll,drag,start", _scroll_cb, layout);
3820         evas_object_smart_callback_add(chat_scroller, "edge,bottom", _edge_cb, layout);
3821         /*add top*/
3822         evas_object_smart_callback_add(chat_scroller, "edge,top", _edge_top_cb, layout);
3823         evas_object_data_set(layout, "is_end_edge", (void *) 1);
3824         /*setting offset_num*/
3825 //      evas_object_data_set(chat_scroller, "offset_num", (void *) 1);
3826         evas_object_data_set(chat_scroller, "prev_h", (void *) 0);
3827         /*check edge is top*/
3828         evas_object_data_set(chat_scroller, "is_end_edge_top",(void*)1);
3829
3830         Evas_Object *align_box = elm_box_add(chat_scroller);
3831         if (!align_box) {
3832                 LOGE("fail to add the box");
3833                 return;
3834         }
3835
3836         elm_box_horizontal_set(align_box, EINA_FALSE);
3837         elm_box_align_set(align_box, 0.5, 0.0);
3838         evas_object_size_hint_weight_set(align_box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3839         evas_object_size_hint_align_set(align_box, EVAS_HINT_FILL, 0.0);
3840         elm_object_content_set(chat_scroller, align_box);
3841         evas_object_show(align_box);
3842
3843         Evas_Object *chat_box = elm_box_add(chat_scroller);
3844         if (!chat_box) {
3845                 LOGE("fail to add the box");
3846                 return;
3847         }
3848         elm_box_horizontal_set(chat_box, EINA_FALSE);
3849         elm_box_align_set(chat_box, 0.5, 0.0);
3850         evas_object_size_hint_weight_set(chat_box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3851         evas_object_size_hint_align_set(chat_box, EVAS_HINT_FILL, 0.0);
3852         evas_object_show(chat_box);
3853         elm_box_pack_end(align_box, chat_box);
3854         evas_object_event_callback_add(chat_box, EVAS_CALLBACK_RESIZE, __resize_cb, ad);
3855
3856         elm_object_part_content_set(msg_box_layout, "swallow.gen_list", chat_scroller);
3857         elm_object_part_content_set(layout, "swallow.chat_box", msg_box_layout);
3858
3859         /********************** START: entry layout*******************************/
3860         Evas_Object* entry_box_layout = elm_layout_add(ad->win);
3861         if (!entry_box_layout) {
3862                 LOGE("Fail to add the entry box layout");
3863         }
3864
3865         elm_layout_file_set(entry_box_layout, edj_path, "chat_entry_box");
3866         evas_object_size_hint_align_set(entry_box_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
3867         evas_object_size_hint_weight_set(entry_box_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3868         evas_object_show(entry_box_layout);
3869
3870         Evas_Object *entry_layout = elm_layout_add(entry_box_layout);
3871         if (!entry_layout) {
3872                 LOGE("Fail to add the entry_layout");
3873         }
3874         elm_layout_theme_set(entry_layout, "layout", "editfield", "singleline");
3875
3876         Evas_Object* text_entry = elm_entry_add(entry_layout);
3877         if (!text_entry) {
3878                 LOGE("Fail to add the text_entry");
3879         }
3880
3881         elm_object_part_text_set(text_entry, "elm.guide", "Text message");
3882         elm_entry_line_wrap_set(text_entry, EINA_TRUE);
3883         elm_entry_scrollable_set(text_entry, EINA_TRUE);
3884         evas_object_size_hint_align_set(text_entry, EVAS_HINT_FILL, EVAS_HINT_FILL);
3885         evas_object_size_hint_weight_set(text_entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3886         evas_object_show(text_entry);
3887         evas_object_data_set(entry_box_layout, "is_attach_show", (void *) 1);
3888
3889         elm_object_part_content_set(entry_layout, "elm.swallow.content", text_entry);
3890         evas_object_smart_callback_add(text_entry, "changed", on_message_text_entry_changed, entry_box_layout);
3891         evas_object_smart_callback_add(text_entry, "preedit,changed", on_message_text_entry_changed, entry_box_layout);
3892         evas_object_smart_callback_add(text_entry, "clicked", on_message_text_entry_clicked, NULL);
3893         elm_object_part_content_set(entry_box_layout, "swallow.text_entry", entry_layout);
3894
3895         /* button clicked event */
3896         elm_object_signal_callback_add(entry_box_layout, "smile", "clicked", on_message_smiley_clicked, text_entry);
3897         elm_object_signal_callback_add(entry_box_layout, "attach", "clicked", on_media_attach_clicked, chat_scroller);
3898         elm_object_signal_callback_add(entry_box_layout, "send", "clicked", on_text_message_send_clicked, chat_scroller);
3899         elm_object_part_content_set(layout, "swallow.entry", entry_box_layout);
3900
3901         /********************** END: entry layout*******************************/
3902
3903         /************************* START: message bubble ************************/
3904
3905         Evas_Object* bubble_layout = elm_layout_add(ad->win);
3906         if (!bubble_layout) {
3907                 LOGE("Fail to add the bubble_layout");
3908         }
3909
3910         elm_layout_file_set(bubble_layout, edj_path, "bubble_layout");
3911         evas_object_size_hint_align_set(bubble_layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
3912         evas_object_size_hint_weight_set(bubble_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3913         evas_object_show(bubble_layout);
3914         elm_object_signal_callback_add(bubble_layout, "cancel", "clicked", on_message_cancel_clicked, layout);
3915         elm_object_part_content_set(layout, "swallow.messagebubble", bubble_layout);
3916         evas_object_data_set(ad->nf, "main_layout", layout);
3917
3918         /********************** END: entry message bubble*******************************/
3919
3920         evas_object_data_set(ad->nf, "chat_list", (void*)chat_scroller);
3921         evas_object_data_set(chat_scroller, "app_data", ad);
3922         evas_object_data_set(chat_scroller, "user_id", (void*)user_id);
3923         evas_object_data_set(chat_scroller, "text_entry", (void*)text_entry);
3924
3925         /* Set the name in title area */
3926
3927         char temp_name[512] = {'\0'};
3928
3929         if ((user->peer_type == TGL_PEER_USER) && get_buddy_unknown_status(user->peer_id)) {
3930                 //snprintf(temp_name, 512, "%s", get_buddy_phone_num_from_id(sel_item->use_data->peer_id));
3931
3932                 char *phone_num = get_buddy_phone_num_from_id(sel_item->use_data->peer_id);
3933
3934                 if (phone_num == NULL || (phone_num && strcmp(phone_num, "+") == 0)) {
3935 #if 0
3936                         char *user_name = NULL;
3937                         char *first_name = NULL;
3938                         char *last_name = NULL;
3939                         char *phone_num = NULL;
3940                         get_buddy_contact_details_from_db(sel_item->use_data->peer_id, &first_name, &last_name, &phone_num);
3941
3942                         if (!first_name || strstr(first_name, "null") != 0) {
3943                                 first_name = NULL;
3944                         }
3945
3946                         if (!first_name && !last_name && phone_num) {
3947                                 first_name = phone_num;
3948                         }
3949
3950                         if (!last_name || strstr(last_name, "null") != 0) {
3951                                 last_name = "";
3952                         }
3953                         user_name = (char*)malloc(strlen(first_name) + strlen(" ") + strlen(last_name) + 1);
3954                         strcpy(user_name, first_name);
3955                         strcat(user_name, " ");
3956                         strcat(user_name, last_name);
3957                         snprintf(temp_name, 512, "%s", user_name);
3958                         free(user_name);
3959 #endif
3960                         if (sel_item->use_data->print_name) {
3961                                 snprintf(temp_name, 512, "%s", sel_item->use_data->print_name);
3962                         } else {
3963                                 snprintf(temp_name, 512, "%s", "unknown");
3964                         }
3965                 } else {
3966                         if (phone_num) {
3967                                 snprintf(temp_name, 512, "%s", phone_num);
3968                         } else {
3969                                 snprintf(temp_name, 512, "%s", "unknown");
3970                         }
3971                 }
3972                 free(phone_num);
3973         } else {
3974                 char* user_name = replace(sel_item->use_data->print_name, '_', " ");
3975                 snprintf(temp_name, 512, "%s", user_name);
3976                 free(user_name);
3977         }
3978
3979         Elm_Object_Item *nf_it = elm_naviframe_item_push(ad->nf, temp_name, NULL, NULL, layout, NULL);
3980         evas_object_data_set(ad->nf, "navi_item", nf_it);
3981
3982         on_user_presence_state_changed(ad, sel_item->use_data->peer_id);
3983
3984         Evas_Object *back_btn = create_button(ad->nf, "naviframe/back_btn/default", NULL);
3985         evas_object_smart_callback_add(back_btn, "clicked", on_message_back_button_clicked, ad);
3986         elm_object_item_part_content_set(nf_it, "elm.swallow.prev_btn", back_btn);
3987         elm_naviframe_item_pop_cb_set(nf_it, _pop_cb, ad);
3988
3989         /******************** expand ************************/
3990         if (user->peer_type == TGL_PEER_CHAT) {
3991                 Evas_Object *expand_pic = NULL;
3992                 expand_pic = elm_image_add(layout);
3993                 evas_object_size_hint_weight_set(expand_pic, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3994                 evas_object_size_hint_align_set(expand_pic, EVAS_HINT_FILL, EVAS_HINT_FILL);
3995                 elm_object_focus_set(expand_pic, EINA_FALSE);
3996                 elm_image_file_set(expand_pic, ui_utils_get_resource(TG_EXPAND_OPEN), NULL);
3997                 evas_object_show(expand_pic);
3998                 evas_object_data_set(expand_pic, "app_data", ad);
3999                 evas_object_data_set(expand_pic, "parent_layout", layout);
4000
4001                 Eina_Bool is_expanded = EINA_FALSE;
4002                 evas_object_data_set(expand_pic, "is_expanded", is_expanded);
4003                 Evas_Object* expand_btn = elm_button_add(ad->layout);
4004                 elm_object_style_set(expand_btn, "transparent");
4005                 evas_object_smart_callback_add(expand_btn, "clicked", on_expand_button_clicked, expand_pic);
4006                 elm_object_content_set(expand_btn, expand_pic);
4007                 evas_object_show(expand_btn);
4008                 elm_object_item_part_content_set(nf_it, "title_right_btn", expand_btn);
4009
4010         }
4011         /******************** expand ************************/
4012
4013         Ecore_Timer *timer = NULL;
4014         timer = ecore_timer_add(0.001f, _load_history_cb, ad->nf);
4015
4016         int buddy_id = sel_item->use_data->peer_id;
4017         char* tablename = get_table_name_from_number(buddy_id);
4018         int offset_num = get_start_offset_num(tablename);
4019         evas_object_data_set(chat_scroller, "offset_num", (void *)(offset_num));
4020
4021         Eina_Bool res = set_all_rows_read(tablename);
4022         if (!res) {
4023                 //failed.
4024         }
4025         free(tablename);
4026
4027         evas_object_data_set(ad->nf, "chat_list_no_msg_text", layout);
4028
4029         send_request_for_marked_as_read(ad, ad->service_client, sel_item->use_data->peer_id, sel_item->use_data->peer_type);
4030         eext_object_event_callback_add(ad->nf, EEXT_CALLBACK_MORE, on_messaging_menu_button_clicked, ad);
4031 }
4032