src/PhnCalllogManager.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file        PhnCalllogManager.cpp
  19  * @brief       This class provides call log APIs
  20  */
  21 #include "PhnAppUtility.h"\r
  22 #include "PhnCalllogManager.h"
  23 #include <FLocales.h>
  24
  25 using namespace Tizen::Base;
  26 using namespace Tizen::Base::Collection;
  27 using namespace Tizen::Base::Utility;
  28 using namespace Tizen::Graphics;
  29 using namespace Tizen::System;
  30 using namespace Tizen::Locales;
  31 using namespace Tizen::Ui::Controls;
  32
  33 CallLogManager* CallLogManager::__pCallogManager = null;
  34 CallLogType CallLogManager::__callLogViewbyID = CALL_LOG_TYPE_ALL;\r
  35 \r
  36 static int TOTAL_CALL_LOGS_TO_FETCH = 500;\r
  37
  38 result
  39 LogListByNumberComparer::Compare(const CallLogDetails& obj1, const CallLogDetails& obj2, int& cmp) const
  40 {
  41         CallLogDetails* log1 = const_cast<CallLogDetails*>((&obj1));
  42         CallLogDetails* log2 = const_cast<CallLogDetails*>((&obj2));
  43         if(log1 == null || log2 == null)
  44         {
  45                 return E_FAILURE;
  46         }
  47         log1->ConvertTimetoDateTime();
  48         DateTime date1 = log1->GetDateTime();
  49         //AppLog(" %d %d %s %d:%d:%d", log1->GetCalllogDbId(), log1->GetCalllogType(), log1->GetPhoneNumber(), date1.GetDay(), date1.GetMonth(), date1.GetYear());
  50         log2->ConvertTimetoDateTime();
  51         DateTime date2 = log2->GetDateTime();
  52         //AppLog(" %d %d %s %d:%d:%d", log2->GetCalllogDbId(), log2->GetCalllogType(), log2->GetPhoneNumber(), date2.GetDay(), date2.GetMonth(), date2.GetYear());
  53         cmp = date2.CompareTo(date1);
  54         return E_SUCCESS;
  55 }
  56
  57 result
  58 LogListComparer::Compare(const Object& obj1, const Object& obj2, int& cmp) const
  59 {
  60         CallLogDetails* log1 = dynamic_cast<CallLogDetails*>(const_cast<Object*>(&obj1));
  61         CallLogDetails* log2 = dynamic_cast<CallLogDetails*>(const_cast<Object*>(&obj2));
  62         if(log1 == null || log2 == null)
  63         {
  64                 return E_FAILURE;
  65         }
  66         log1->ConvertTimetoDateTime();
  67         DateTime date1 = log1->GetDateTime();
  68         //AppLog(" %d %d %s %d:%d:%d", log1->GetCalllogDbId(), log1->GetCalllogType(), log1->GetPhoneNumber(), date1.GetDay(), date1.GetMonth(), date1.GetYear());
  69         log2->ConvertTimetoDateTime();
  70         DateTime date2 = log2->GetDateTime();
  71         //AppLog(" %d %d %s %d:%d:%d", log2->GetCalllogDbId(), log2->GetCalllogType(), log2->GetPhoneNumber(), date2.GetDay(), date2.GetMonth(), date2.GetYear());
  72         cmp = date2.CompareTo(date1);
  73         return E_SUCCESS;
  74 }
  75
  76 CallLogDetails::CallLogDetails(void)
  77 {
  78         dateTime.SetValue(0,0,0);
  79         first_name = null;
  80         last_name = null;
  81         display_name = null;
  82         contact_image_path = null;
  83         phone_number = null;
  84         short_message = null;
  85         contact_db_id = -1;
  86         __consecutiveNoCounter = 1;\r
  87         __pDBIds = null;\r
  88 }
  89
  90 CallLogDetails::~CallLogDetails(void)
  91 {
  92         //NOTE: none of the fields are owned. Free() them will lead to crash.
  93 }
  94
  95 bool
  96 CallLogDetails::operator ==(const CallLogDetails& rhs) const
  97 {
  98         if(this->calllog_db_id == rhs.calllog_db_id)
  99         {
 100                 return true;
 101         }
 102         return false;
 103 }
 104
 105 bool
 106 CallLogDetails::operator !=(const CallLogDetails& rhs) const
 107 {
 108         if(this->calllog_db_id != rhs.calllog_db_id)
 109         {
 110                 return true;
 111         }
 112         return false;
 113 }
 114
 115 CallLogDetails&
 116 CallLogDetails::operator =(const CallLogDetails& rhs)
 117 {
 118         this->calllog_db_id = rhs.calllog_db_id;
 119         this->contact_db_id = rhs.contact_db_id;
 120         this->calllog_type = rhs.calllog_type;
 121         this->duration_sec = rhs.duration_sec;
 122         if(rhs.phone_number != null)
 123         {
 124                 this->phone_number = strdup(rhs.phone_number);
 125         }
 126         this->startTime = rhs.startTime;
 127         return *this;
 128 }
 129
 130
 131 void
 132 CallLogDetails::SetCalllogDbId(int id)
 133 {
 134         calllog_db_id = id;
 135 }
 136
 137
 138 int
 139 CallLogDetails::GetCalllogDbId(void)
 140 {
 141         return calllog_db_id;
 142 }
 143
 144 void
 145 CallLogDetails::SetCalllogType(contacts_phone_log_type_e type)
 146 {
 147         switch (type)
 148         {
 149         case CONTACTS_PLOG_TYPE_VOICE_INCOMMING:
 150                 calllog_type = CALL_LOG_TYPE_VOICE_INCOMING;
 151                 break;
 152         case CONTACTS_PLOG_TYPE_VOICE_OUTGOING:
 153                 calllog_type = CALL_LOG_TYPE_VOICE_OUTGOING;
 154                 break;
 155         case CONTACTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN:
 156                 calllog_type = CALL_LOG_TYPE_VOICE_MISSED_UNSEEN;
 157                 break;
 158         case CONTACTS_PLOG_TYPE_VOICE_INCOMMING_SEEN:
 159                 calllog_type = CALL_LOG_TYPE_VOICE_MISSED;
 160                 break;
 161         case CONTACTS_PLOG_TYPE_VOICE_REJECT:
 162                 calllog_type = CALL_LOG_TYPE_VOICE_REJECTED;
 163                 break;
 164         case CONTACTS_PLOG_TYPE_VOICE_BLOCKED:
 165                 calllog_type = CALL_LOG_TYPE_VOICE_BLOCKED;
 166                 break;
 167
 168
 169         case CONTACTS_PLOG_TYPE_VIDEO_INCOMMING:
 170                 calllog_type = CALL_LOG_TYPE_VIDEO_INCOMING;
 171                 break;
 172         case CONTACTS_PLOG_TYPE_VIDEO_OUTGOING:
 173                 calllog_type = CALL_LOG_TYPE_VIDEO_OUTGOING;
 174                 break;
 175         case CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_UNSEEN:
 176         case CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_SEEN:
 177                 calllog_type = CALL_LOG_TYPE_VIDEO_MISSED;
 178                 break;
 179         case CONTACTS_PLOG_TYPE_VIDEO_REJECT:
 180                 calllog_type = CALL_LOG_TYPE_VIDEO_REJECTED;
 181                 break;
 182         case CONTACTS_PLOG_TYPE_VIDEO_BLOCKED:
 183                 calllog_type = CALL_LOG_TYPE_VIDEO_BLOCKED;
 184                 break;
 185
 186         case CONTACTS_PLOG_TYPE_MMS_INCOMMING:
 187                 calllog_type = CALL_LOG_TYPE_MMS_INCOMING;
 188                 break;
 189         case CONTACTS_PLOG_TYPE_MMS_OUTGOING:
 190                 calllog_type = CALL_LOG_TYPE_MMS_OUTGOING;
 191                 break;
 192         case CONTACTS_PLOG_TYPE_MMS_BLOCKED:
 193                 calllog_type = CALL_LOG_TYPE_SMS_BLOCKED;
 194                 break;
 195
 196         case CONTACTS_PLOG_TYPE_SMS_INCOMMING:
 197                 calllog_type = CALL_LOG_TYPE_SMS_INCOMING;
 198                 break;
 199         case CONTACTS_PLOG_TYPE_SMS_OUTGOING:
 200                 calllog_type = CALL_LOG_TYPE_SMS_OUTGOING;
 201                 break;
 202         case CONTACTS_PLOG_TYPE_SMS_BLOCKED:
 203                 calllog_type = CALL_LOG_TYPE_SMS_BLOCKED;
 204                 break;
 205
 206         case CONTACTS_PLOG_TYPE_EMAIL_RECEIVED:
 207                 calllog_type = CALL_LOG_TYPE_EMAIL_INCOMING;
 208                 break;
 209         case CONTACTS_PLOG_TYPE_EMAIL_SENT:
 210                 calllog_type = CALL_LOG_TYPE_EMAIL_OUTGOING;
 211                 break;
 212
 213         default:
 214                 break;
 215         }
 216 }
 217
 218 CallLogType
 219 CallLogDetails::GetCalllogType(void)
 220 {
 221         return calllog_type;
 222 }
 223
 224 void
 225 CallLogDetails::SetContactDbId(int id)
 226 {
 227         contact_db_id = id;
 228 }
 229
 230 int
 231 CallLogDetails::GetContactDbId(void)
 232 {
 233         return contact_db_id;
 234 }
 235
 236 void
 237 CallLogDetails::SetFirstName(char* name)
 238 {
 239         first_name = strdup(name);
 240 }
 241
 242 char*
 243 CallLogDetails::GetFirstName(void)
 244 {
 245         return first_name;
 246 }
 247
 248 void
 249 CallLogDetails::SetLastName(char* name)
 250 {
 251         last_name = strdup(name);
 252 }
 253
 254 char*
 255 CallLogDetails::GetLastName(void)
 256 {
 257         return last_name;
 258 }
 259
 260 void
 261 CallLogDetails::SetDisplayName(char* name)
 262 {
 263         display_name = strdup(name);
 264 }
 265
 266 char*
 267 CallLogDetails::GetDisplayName(void)
 268 {
 269         return display_name;
 270 }
 271
 272 void
 273 CallLogDetails::SetContactImagePath(char* name)
 274 {
 275         contact_image_path = strdup(name);
 276 }
 277
 278 char*
 279 CallLogDetails::GetContactImagePath(void)
 280 {
 281         return contact_image_path;
 282 }
 283
 284 void
 285 CallLogDetails::SetPhoneNumber(char* name)
 286 {
 287         phone_number = strdup(name);
 288 }
 289
 290 char*
 291 CallLogDetails::GetPhoneNumber(void)
 292 {
 293         return phone_number;
 294 }
 295
 296 void
 297 CallLogDetails::SetShortMessage(char* name)
 298 {
 299         short_message = strdup(name);
 300 }
 301
 302 char*
 303 CallLogDetails::GetShortMessage(void)
 304 {
 305         return short_message;
 306 }
 307
 308 void
 309 CallLogDetails::ConvertTimetoDateTime(void)
 310 {
 311         DateTime dtNow;
 312         struct tm* time = null;
 313         time = gmtime(&startTime);
 314         LocaleManager localManager;
 315         TimeZone tz;
 316         if(time != null)
 317         {
 318                 dtNow.SetValue(time->tm_year+1900,time->tm_mon+1, time->tm_mday,time->tm_hour, time->tm_min, time->tm_sec);
 319
 320         }
 321         localManager.Construct();
 322         tz = localManager.GetSystemTimeZone();
 323         dateTime = tz.UtcTimeToWallTime(dtNow);
 324
 325
 326 }
 327
 328 void
 329 CallLogDetails::SetStartTime(time_t time)
 330 {
 331         startTime = time;
 332         ConvertTimetoDateTime();
 333 }
 334
 335 time_t
 336 CallLogDetails::GetStartTime(void)
 337 {
 338         return startTime;
 339 }
 340
 341 DateTime
 342 CallLogDetails::GetDateTime(void)
 343 {
 344         return dateTime;
 345 }
 346
 347 void
 348 CallLogDetails::SetDuration(int duration)
 349 {
 350         duration_sec = duration;
 351 }
 352
 353 int
 354 CallLogDetails::GetDuration(void)
 355 {
 356         return duration_sec;
 357 }
 358
 359 int\r
 360 CallLogDetails::GetConsecutiveNoCounter()\r
 361 {\r
 362         return __consecutiveNoCounter;\r
 363 }\r
 364 \r
 365 void\r
 366 CallLogDetails::SetConsecutiveNoCounter(int consecutiveNoCounter)\r
 367 {\r
 368         __consecutiveNoCounter = consecutiveNoCounter;\r
 369 }\r
 370 \r
 371 Tizen::Base::Collection::ArrayList*\r
 372 CallLogDetails::GetCallLogDbIds()\r
 373 {\r
 374         return __pDBIds;\r
 375 }\r
 376 \r
 377 void\r
 378 CallLogDetails::SetCallLogDbIds(Tizen::Base::Collection::ArrayList* dbIds)\r
 379 {\r
 380         __pDBIds = dbIds;\r
 381 }\r
 382 \r
 383 CallLogManager*
 384 CallLogManager::GetInstance(void)
 385 {
 386         if(__pCallogManager == null)
 387         {
 388                 CreateInstance();
 389         }
 390         return __pCallogManager;
 391 }
 392
 393 void
 394 CallLogManager::CreateInstance(void)
 395 {
 396         __pCallogManager = new CallLogManager();
 397         result r = __pCallogManager->Construct();
 398         if(IsFailed(r))
 399         {
 400                 delete __pCallogManager;
 401                 __pCallogManager = null;
 402                 return;
 403         }
 404         std::atexit(DestroyInstance);
 405 }
 406 void
 407 CallLogManager::DestroyInstance(void)
 408 {
 409         contacts_disconnect2();
 410         delete __pCallogManager;
 411 }
 412 result
 413 CallLogManager::Construct(void)
 414 {
 415         int ret = contacts_connect2();
 416         if(ret != 0)
 417         {
 418                 return E_FAILURE;
 419         }
 420         \r
 421         __callLogViewbyID = CALL_LOG_TYPE_ALL;\r
 422         __callLogsViewedCount = 0;\r
 423
 424         __pCalllogGroupList = new (std::nothrow) ArrayList();\r
 425         __pCalllogGroupList->Construct();\r
 426         __pCalllogChangeListerners = new (std::nothrow) ArrayListT<ICalllogChangeListener*>;
 427         __pCalllogChangeListerners->Construct(10);
 428         __pCalllogDBIds = new (std::nothrow) HashMapT<int,int>();
 429         __pCalllogDBIds->Construct(100);
 430
 431         //GetAllCallogDataFromDatabseCB();
 432         contacts_db_add_changed_cb(_contacts_phone_log._uri,CallLogManager::ContactsDbchangedcb,this);
 433         SortCalllogList();
 434         //TODO
 435         //calllog_add_calllog_db_changed_cb(changed_db_cb, this);
 436         return E_SUCCESS;
 437
 438 }
 439 ///////////////////////////////////////Calllog Manager////////////////////////////////////////////////////////////////////////////////
 440 CallLogManager::CallLogManager(void)
 441 {
 442         __pCalllogGroupList = null;\r
 443         __pCalllogListByNumber = null;
 444         __pNumber = null;
 445         __pCalllogChangeListerners = null;
 446         __bDbDirty = true;
 447 }
 448
 449 CallLogManager::~CallLogManager(void)
 450 {
 451         AppLogDebug("Enter");
 452         DeleteAllCallLogCacheEntries();\r
 453         if(__pCalllogListByNumber != null)
 454         {
 455                 __pCalllogListByNumber = null;
 456         }
 457         if(__pNumber != null)
 458         {
 459                 delete __pNumber;
 460                 __pNumber = null;
 461         }
 462         if(__pCalllogDBIds != null)
 463         {
 464                 __pCalllogDBIds->RemoveAll();
 465                 delete __pCalllogDBIds;
 466         }
 467         if(__pCalllogChangeListerners != null)
 468         {
 469                 delete __pCalllogChangeListerners;
 470         }
 471         contacts_db_remove_changed_cb(_contacts_phone_log._uri,CallLogManager::ContactsDbchangedcb,null);
 472         __pCallogManager = null;
 473 }
 474
 475 void\r
 476 CallLogManager::DeleteAllCallLogCacheEntries(void)\r
 477 {\r
 478         if(__pCalllogGroupList != null)\r
 479         {\r
 480                 ArrayList* pCalllogList = null;\r
 481                 GroupItemClass* pGroupInfo = null;\r
 482                 for(int index = 0; index < __pCalllogGroupList->GetCount(); index++)\r
 483                 {\r
 484                         pGroupInfo = static_cast<GroupItemClass*>(__pCalllogGroupList->GetAt(index));\r
 485                         if(pGroupInfo != null)\r
 486                         {\r
 487                                 pCalllogList = pGroupInfo->GetLogData();\r
 488                                 if(pCalllogList != null)\r
 489                                 {\r
 490                                         pCalllogList->RemoveAll();\r
 491                                         delete pCalllogList;\r
 492                                         pCalllogList = null;\r
 493                                 }\r
 494                                 delete pGroupInfo;\r
 495                                 pGroupInfo = null;\r
 496                         }\r
 497                 }\r
 498                 __pCalllogGroupList->RemoveAll();\r
 499                 delete __pCalllogGroupList;\r
 500                 __pCalllogGroupList = null;\r
 501         }\r
 502 }\r
 503 unsigned long
 504 CallLogManager::GetDuration(long long start_time)
 505 {
 506         time_t curr_time;
 507         unsigned long call_duration_in_sec = 50;
 508         curr_time = time(0);
 509         call_duration_in_sec = curr_time - start_time;
 510         return call_duration_in_sec;
 511 }
 512
 513 void
 514 CallLogManager::CopyDataToCallLogDetails(CallLogDetails* calllogInfo , contacts_record_h getrec)
 515 {
 516         int logid=0;
 517         contacts_record_get_int(getrec,_contacts_phone_log.id,&logid);
 518         calllogInfo->SetCalllogDbId(logid);
 519
 520         contacts_phone_log_type_e logType=CONTACTS_PLOG_TYPE_NONE;
 521         contacts_record_get_int(getrec,_contacts_phone_log.log_type,(int*)&logType);
 522         calllogInfo->SetCalllogType(logType);
 523
 524         int log_time=0;
 525         contacts_record_get_int(getrec,_contacts_phone_log.log_time,&log_time);
 526         calllogInfo->SetStartTime((time_t)log_time);
 527
 528         char* address = null;
 529         int ret = contacts_record_get_str(getrec,_contacts_phone_log.address,&address);
 530         if(ret == 0 && address != null)
 531         {
 532                 calllogInfo->SetPhoneNumber(address);
 533                 free(address);
 534         }
 535
 536         int duration=0;
 537         contacts_record_get_int(getrec,_contacts_phone_log.extra_data1,&duration);
 538         calllogInfo->SetDuration(duration);
 539
 540         char* shortMsg=0;
 541         contacts_record_get_str(getrec,_contacts_phone_log.extra_data2,&shortMsg);
 542         if(shortMsg)
 543         calllogInfo->SetShortMessage(shortMsg);
 544
 545 }
 546
 547 bool
 548 CallLogManager::GetAllCallogDataFromDatabseCB()
 549 {
 550         contacts_list_h list=NULL;\r
 551         unsigned int count = 0;\r
 552         int ret = 0;\r
 553         __callLogsViewedCount = 0;\r
 554
 555         if(QueryCallogDatabse(&list) == false)\r
 556         {
 557                 AppLogDebug("Getting records from callLog database is failed!");\r
 558                 return false;
 559         }
 560         ret =  contacts_list_get_count(list,&count);\r
 561         contacts_list_first(list);\r
 562
 563         DateTime today, yesterday, tomorrow;\r
 564         TimeSpan oneDay(1,0,0,0);\r
 565         GetCurrentDateTime(today);\r
 566         today.Subtract(today.GetTimeOfDay());\r
 567
 568         yesterday = today;\r
 569         yesterday.Subtract(oneDay);\r
 570         tomorrow = today;\r
 571         tomorrow.Add(oneDay);\r
 572 \r
 573         String title;\r
 574         DateTime calllogDate;\r
 575 \r
 576         for (unsigned int i = 0; i < count; i++)
 577         {
 578                 CallLogDetails* pCalllogInfo = new CallLogDetails();\r
 579                 contacts_record_h getrec=0;
 580                 ret = contacts_list_get_current_record_p(list,&getrec);
 581                 if(ret == 0)
 582                 {
 583                         contacts_phone_log_type_e logType=CONTACTS_PLOG_TYPE_NONE;
 584                         contacts_record_get_int(getrec,_contacts_phone_log.log_type,(int*)&logType);
 585
 586                         if(logType != CONTACTS_PLOG_TYPE_EMAIL_RECEIVED && logType !=CONTACTS_PLOG_TYPE_EMAIL_SENT)
 587                         {
 588                                 CopyDataToCallLogDetails(pCalllogInfo, getrec);\r
 589 \r
 590                                 if(__pCalllogDBIds->Add(pCalllogInfo->GetCalllogDbId(),pCalllogInfo->GetCalllogDbId()) == E_SUCCESS)\r
 591                                 {
 592                                         __callLogsViewedCount++;\r
 593                                         //find title\r
 594                                         pCalllogInfo->ConvertTimetoDateTime();\r
 595                                         calllogDate = pCalllogInfo->GetDateTime();\r
 596                                         title.Clear();\r
 597                                         if(calllogDate >= today && calllogDate < tomorrow)\r
 598                                         {\r
 599                                                 title.Append(AppUtility::GetResourceString(IDS_LOGS_TODAY));\r
 600                                         }\r
 601                                         else if(calllogDate >= yesterday && calllogDate < today)\r
 602                                         {\r
 603                                                 title.Append(AppUtility::GetResourceString(IDS_LOGS_YESTERDAY));\r
 604                                         }\r
 605                                         else\r
 606                                         {\r
 607                                                 title.Format(30,L"%d/%d/%d",calllogDate.GetDay(), calllogDate.GetMonth(), calllogDate.GetYear());\r
 608                                         }\r
 609                                         CreateCallLogGroup(pCalllogInfo, title);\r
 610                                 }
 611                         }
 612                 }
 613                 //move to next record
 614                 ret = contacts_list_next(list);
 615                 if (ret != 0)
 616                 {
 617                         continue;
 618                 }
 619                 contacts_record_destroy(getrec,true);
 620         }
 621         contacts_list_destroy(list,false);
 622         return true;\r
 623 }\r
 624 \r
 625 bool\r
 626 CallLogManager::QueryCallogDatabse(contacts_list_h* list)\r
 627 {\r
 628         contacts_filter_h filter=NULL;\r
 629         contacts_query_h query = NULL;\r
 630         int ret = 0;\r
 631         //get all logs\r
 632         if(getCallLogViewbyID() == CALL_LOG_TYPE_ALL)\r
 633         {\r
 634                 int calLogCount =  0;\r
 635                 contacts_db_get_count(_contacts_phone_log._uri,&calLogCount);\r
 636                 ret = contacts_db_get_all_records(_contacts_phone_log._uri,0,TOTAL_CALL_LOGS_TO_FETCH,list);\r
 637                 if (ret != 0)\r
 638                 {\r
 639                         return false;\r
 640                 }\r
 641         }\r
 642         else\r
 643         {\r
 644                 contacts_filter_create(_contacts_phone_log._uri,&filter);\r
 645                 //get Received/Dialed call logs only\r
 646                 if (getCallLogViewbyID() == CALL_LOG_TYPE_VOICE_INCOMING || getCallLogViewbyID() == CALL_LOG_TYPE_VOICE_OUTGOING)\r
 647                 {\r
 648                         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, GetCallLogType(getCallLogViewbyID()));\r
 649                 }\r
 650                 else\r
 651                 {\r
 652                         //get Missed/Missed Unseen call logs only or rejected/blocked call logs only\r
 653                         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, GetCallLogType(getCallLogViewbyID()));\r
 654                         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);\r
 655                         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, GetCallLogType((CallLogType)(getCallLogViewbyID()+1)));\r
 656                 }\r
 657                 contacts_query_create(_contacts_phone_log._uri,&query);\r
 658                 contacts_query_set_filter(query,filter);\r
 659                 ret = contacts_db_get_records_with_query(query,0,TOTAL_CALL_LOGS_TO_FETCH,list);\r
 660                 if (ret != 0)\r
 661                 {\r
 662                         contacts_filter_destroy(filter);\r
 663                         contacts_query_destroy(query);\r
 664                         return false;\r
 665                 }\r
 666                 contacts_filter_destroy(filter);\r
 667                 contacts_query_destroy(query);\r
 668         }\r
 669         return true;
 670 }
 671
 672 void\r
 673 CallLogManager::CreateCallLogGroup(CallLogDetails* pCalllogInfo, String title)\r
 674 {\r
 675         GroupItemClass* pGroupItemClass;\r
 676         ArrayList* pData = null;\r
 677         //find if group with this title is already found\r
 678         pGroupItemClass = GetGroupWithTitle(title);\r
 679         if (pGroupItemClass != null)\r
 680         {\r
 681                 pData = pGroupItemClass->GetLogData();\r
 682 \r
 683                 String today = AppUtility::GetResourceString(IDS_LOGS_TODAY);\r
 684                 String yesterday = AppUtility::GetResourceString(IDS_LOGS_YESTERDAY);\r
 685 \r
 686                 //In case of Today or Yesterday logs group, if logs with same number present consecutively we will show the count instead of multiple entries.\r
 687                 if((today.CompareTo(pGroupItemClass->GetTitleText()) == 0) || (yesterday.CompareTo(pGroupItemClass->GetTitleText()) == 0))\r
 688                 {\r
 689                         CallLogDetails* pCurrCalllogInf = static_cast<CallLogDetails*>(pData->GetAt(0));\r
 690                         if(String::Compare(String(pCurrCalllogInf->GetPhoneNumber()), String(pCalllogInfo->GetPhoneNumber())) == 0)\r
 691                         {\r
 692                                 Tizen::Base::Collection::ArrayList* dbIds = pCurrCalllogInf->GetCallLogDbIds();\r
 693                                 if(dbIds == null)\r
 694                                 {\r
 695                                         dbIds = new ArrayList();\r
 696                                         dbIds->Construct();\r
 697                                         dbIds->Add(new Integer(pCalllogInfo->GetCalllogDbId()));\r
 698                                         dbIds->Add(new Integer(pCurrCalllogInf->GetCalllogDbId()));\r
 699                                 }\r
 700                                 else\r
 701                                 {\r
 702                                         dbIds->InsertAt(new Integer(pCalllogInfo->GetCalllogDbId()), 0);\r
 703                                 }\r
 704                                 pCalllogInfo->SetConsecutiveNoCounter(pCurrCalllogInf->GetConsecutiveNoCounter() + 1);\r
 705                                 pCalllogInfo->SetCallLogDbIds(dbIds);\r
 706                                 pData->RemoveAt(0, true);\r
 707                                 __callLogsViewedCount--;\r
 708                         }\r
 709                 }\r
 710                 pData->InsertAt(pCalllogInfo,0);\r
 711                 pGroupItemClass->SetLogData(pData);\r
 712         }\r
 713         else\r
 714         {\r
 715                 //Create a new group\r
 716                 pGroupItemClass = new(std::nothrow) GroupItemClass();\r
 717                 pGroupItemClass->SetTitleText(title);\r
 718 \r
 719                 __pCalllogGroupList->InsertAt(pGroupItemClass, 0);\r
 720                 pData = pGroupItemClass->GetLogData();\r
 721                 if(pData == null)\r
 722                 {\r
 723                         pData = new ArrayList();\r
 724                 }\r
 725                 pData->InsertAt(pCalllogInfo,0);\r
 726                 pGroupItemClass->SetLogData(pData);\r
 727         }\r
 728 }\r
 729 \r
 730 GroupItemClass*\r
 731 CallLogManager::GetGroupWithTitle(String title)\r
 732 {\r
 733         GroupItemClass* pGroupInfo = null;\r
 734         int count = __pCalllogGroupList->GetCount();\r
 735         for(int index = 0; index < count; index++)\r
 736         {\r
 737                 pGroupInfo = static_cast<GroupItemClass*>(__pCalllogGroupList->GetAt(index));\r
 738                 if(pGroupInfo == null)\r
 739                 {\r
 740                         return null;\r
 741                 }\r
 742                 String title1 = pGroupInfo->GetTitleText();\r
 743                 if( title.CompareTo(title1) == 0)\r
 744                 {\r
 745                         return pGroupInfo;\r
 746                 }\r
 747         }\r
 748         return null;\r
 749 }\r
 750 \r
 751 void\r
 752 CallLogManager::DeleteItemAtGroupIndex(int groupIndex, int itemIndex)\r
 753 {\r
 754         if(__pCalllogGroupList != null)\r
 755         {\r
 756                 GroupItemClass* pGroupInfo = null;\r
 757                 ArrayList* list = null;\r
 758                 pGroupInfo = static_cast<GroupItemClass*>(__pCalllogGroupList->GetAt(groupIndex));\r
 759                 if(pGroupInfo != null)\r
 760                 {\r
 761                         list = pGroupInfo->GetLogData();\r
 762                         list->RemoveAt(itemIndex,true);\r
 763                 }\r
 764         }\r
 765 }\r
 766 \r
 767 bool\r
 768 CallLogManager::GetCurrentDateTime(DateTime& dt)\r
 769 {\r
 770         DateTime dtNow;\r
 771         LocaleManager localManager;\r
 772         result r = E_FAILURE;\r
 773         TimeZone tz;\r
 774 \r
 775         r = SystemTime::GetCurrentTime(UTC_TIME, dtNow);\r
 776         if (IsFailed(r))\r
 777         {\r
 778                 return false;\r
 779         }\r
 780         localManager.Construct();\r
 781         tz = localManager.GetSystemTimeZone();\r
 782         dt = tz.UtcTimeToWallTime(dtNow);\r
 783 \r
 784         return true;\r
 785 }\r
 786
 787 void
 788 CallLogManager::ResetAndNotifyCalllogData(void)
 789 {
 790         __bDbDirty = true;
 791         IEnumeratorT<ICalllogChangeListener*>* pListenerEnum = null;
 792         result r = E_FAILURE;
 793         if (__pCalllogChangeListerners != null)
 794         {
 795                 pListenerEnum = __pCalllogChangeListerners->GetEnumeratorN();
 796                 while ((r = pListenerEnum->MoveNext()) != E_OUT_OF_RANGE)
 797                 {
 798                         ICalllogChangeListener* pListener;
 799                         r = pListenerEnum->GetCurrent(pListener);
 800                         pListener->OnCalllogChanged();
 801
 802                 }
 803         }
 804
 805 }
 806
 807 void
 808 CallLogManager::UpdateCallLogList()
 809 {
 810         DeleteAllCallLogCacheEntries();\r
 811         if(__pCalllogDBIds != null)
 812         {
 813                 __pCalllogDBIds->RemoveAll();
 814                 delete __pCalllogDBIds;
 815                 __pCalllogDBIds = null;
 816         }
 817
 818         __pCalllogGroupList = new (std::nothrow) ArrayList();\r
 819         __pCalllogGroupList->Construct();\r
 820         __pCalllogDBIds = new (std::nothrow) HashMapT<int,int>;
 821         __pCalllogDBIds->Construct(100);
 822         GetAllCallogDataFromDatabseCB();
 823         SortCalllogList();
 824         __bDbDirty = false;
 825 }
 826
 827
 828
 829 IListT<CallLogDetails>*
 830 CallLogManager::GetCalllogListByNumValues(void)
 831 {
 832         if(__pCalllogListByNumber != null)
 833         {
 834                 return __pCalllogListByNumber->GetItemsN(0, __pCalllogListByNumber->GetCount());
 835         }
 836         return null;
 837 }
 838
 839 bool
 840 CallLogManager::GetCallogListByNumberFromDatabaseCB(char* number)
 841 {
 842
 843         contacts_filter_h filter=NULL;
 844         contacts_list_h list=NULL;
 845         contacts_query_h query = NULL;
 846         unsigned int count = 0;
 847         int ret = 0;
 848
 849         contacts_filter_create(_contacts_phone_log._uri,&filter);
 850         contacts_filter_add_str(filter,_contacts_phone_log.address,CONTACTS_MATCH_EXACTLY,number);
 851         contacts_query_create(_contacts_phone_log._uri,&query);
 852         contacts_query_set_filter(query,filter);
 853
 854         ret = contacts_db_get_records_with_query(query,0,0,&list);
 855         if (ret != 0)
 856         {
 857                 contacts_filter_destroy(filter);
 858                 contacts_query_destroy(query);
 859                 return false;
 860         }
 861         contacts_filter_destroy(filter);
 862         contacts_query_destroy(query);
 863
 864
 865         contacts_list_get_count(list,&count);
 866         contacts_list_first(list);
 867         for(unsigned int i=0;i<count;i++)
 868         {
 869                 CallLogDetails* calllogInfo = new CallLogDetails();
 870                 contacts_record_h getrec=0;
 871                 result ret = contacts_list_get_current_record_p(list,&getrec);
 872                 if(ret == 0)
 873                 {
 874                         contacts_phone_log_type_e logType=CONTACTS_PLOG_TYPE_NONE;
 875                         contacts_record_get_int(getrec,_contacts_phone_log.log_type,(int*)&logType);
 876                         if(logType != CONTACTS_PLOG_TYPE_EMAIL_RECEIVED && logType !=CONTACTS_PLOG_TYPE_EMAIL_SENT)
 877                         {
 878                                 CopyDataToCallLogDetails(calllogInfo, getrec);
 879                                 __pCalllogListByNumber->InsertAt(*calllogInfo, 0);\r
 880                         }
 881
 882                 }
 883
 884                 delete calllogInfo;
 885                 ret = contacts_list_next(list);
 886                 if (ret != 0)
 887                 {
 888                         continue;
 889                 }
 890                 contacts_record_destroy(getrec,true);
 891         }
 892
 893         return true;
 894 }
 895
 896 Tizen::Base::Collection::ArrayListT<CallLogDetails>*
 897 CallLogManager::GetCallogListByNumberFromDatabaseN(char* number)
 898 {
 899         __pCalllogListByNumber = new (std::nothrow) Tizen::Base::Collection::ArrayListT<CallLogDetails>();
 900         __pCalllogListByNumber->Construct(100);
 901         if(__pNumber != null)
 902         {
 903                 delete __pNumber;
 904         }
 905         int len = strlen(number) + 1;
 906         __pNumber = new (std::nothrow) char[len];
 907         strcpy(__pNumber,number);
 908
 909         GetCallogListByNumberFromDatabaseCB(number);
 910
 911         if (__pCalllogListByNumber->GetCount() > 0)
 912         {
 913                 SortCalllogListByNumber();\r
 914                 return __pCalllogListByNumber;
 915         }
 916         delete __pCalllogListByNumber;
 917         __pCalllogListByNumber = null;
 918         return null;
 919 }
 920
 921 HashMapT<int, CallLogDetails>*
 922 CallLogManager::GetCallogListByUnknownNumberFromDatabaseN(char* number)
 923 {
 924         //Used to fetch list of call from unknown numbers from logs.
 925         __pCalllogUnkownListByNumber = new (std::nothrow) HashMapT<int, CallLogDetails>();
 926         __pCalllogUnkownListByNumber->Construct(100);
 927         if(__pNumber != null)
 928         {
 929                 delete __pNumber;
 930         }
 931         int len = strlen(number) + 1;
 932         __pNumber = new (std::nothrow) char[len];
 933         strcpy(__pNumber,number);
 934
 935         GetCallogListByNumberFromDatabaseCB(number);
 936         if (__pCalllogUnkownListByNumber->GetCount() > 0)
 937         {
 938                 return __pCalllogUnkownListByNumber;
 939         }
 940         delete __pCalllogUnkownListByNumber;
 941         __pCalllogUnkownListByNumber = null;
 942         return null;
 943 }
 944
 945 void
 946 CallLogManager::DeleteCalllogByDbId(int dbId)
 947 {
 948         contacts_db_delete_record(_contacts_phone_log._uri,dbId);
 949 }
 950
 951 void
 952 CallLogManager::DeleteAllCalllog(void)
 953 {
 954         if(__pCalllogGroupList != null)\r
 955         {\r
 956                 ArrayList* pCalllogList = null;\r
 957                 GroupItemClass* pGroupInfo = null;\r
 958                 CallLogDetails* pLatestCallLog;\r
 959                 int count =0;\r
 960
 961                 for(int index = 0; index < __pCalllogGroupList->GetCount(); index++)\r
 962                 {\r
 963                         pGroupInfo = static_cast<GroupItemClass*>(__pCalllogGroupList->GetAt(index));\r
 964
 965                         if(pGroupInfo != null)\r
 966                         {\r
 967                                 pCalllogList = pGroupInfo->GetLogData();\r
 968                                 if(pCalllogList != null)\r
 969                                 {\r
 970                                         count = pCalllogList->GetCount();\r
 971                                         for(int i=0; i< count; i++)\r
 972                                         {\r
 973                                                 pLatestCallLog = static_cast<CallLogDetails*>(pCalllogList->GetAt(i));\r
 974                                                 contacts_db_delete_record(_contacts_phone_log._uri,pLatestCallLog->GetCalllogDbId());\r
 975                                         }\r
 976                                         pCalllogList->RemoveAll();\r
 977                                         delete pCalllogList;\r
 978                                         pCalllogList = null;\r
 979                                 }\r
 980                                 delete pGroupInfo;\r
 981                                 pGroupInfo = null;\r
 982                         }\r
 983                 }
 984                 __pCalllogGroupList->RemoveAll();\r
 985                 delete __pCalllogGroupList;\r
 986                 __pCalllogGroupList = null;\r
 987         }
 988 \r
 989         contacts_phone_log_reset_statistics();\r
 990         AppLogDebug("Exit");
 991 }
 992
 993 int
 994 CallLogManager::GetAllCallLogCount(void)\r
 995 {
 996         int calLogCount =  0;\r
 997         contacts_filter_h filter=NULL;
 998         contacts_query_h query = NULL;
 999
1000         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING);
1001         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1002
1003         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_OUTGOING);
1004         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1005
1006         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING);
1007         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1008
1009         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_OUTGOING);
1010         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1011
1012         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN);
1013         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1014
1015         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_INCOMMING_SEEN);
1016         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1017
1018         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_UNSEEN);
1019         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1020
1021         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_INCOMMING_SEEN);
1022         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1023
1024         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_REJECT);
1025         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1026
1027         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_REJECT);
1028         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1029
1030         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VOICE_BLOCKED);
1031         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1032
1033         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_VIDEO_BLOCKED);
1034         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1035
1036         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_MMS_INCOMMING);
1037         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1038
1039         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_MMS_OUTGOING);
1040         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1041
1042         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_SMS_INCOMMING);
1043         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1044
1045         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_SMS_OUTGOING);
1046         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1047
1048         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_SMS_BLOCKED);
1049         contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_OR);
1050
1051         contacts_filter_add_int(filter,_contacts_phone_log.log_type, CONTACTS_MATCH_EQUAL, CONTACTS_PLOG_TYPE_MMS_BLOCKED);
1052
1053         contacts_query_create(_contacts_phone_log._uri,&query);
1054         contacts_query_set_filter(query,filter);
1055
1056         contacts_db_get_count_with_query(query,&calLogCount);
1057         contacts_filter_destroy(filter);
1058         contacts_query_destroy(query);
1059
1060         AppLogDebug("contacts_db_get_count_with_query %d",calLogCount);\r
1061         return calLogCount;\r
1062 }\r
1063 \r
1064 int\r
1065 CallLogManager::GetCallLogsViewedCount()\r
1066 {
1067         AppLogDebug("%d",__callLogsViewedCount);\r
1068         return __callLogsViewedCount;\r
1069 }
1070
1071 int
1072 CallLogManager::GetCalllogCountByNumber(void)
1073 {
1074         if(__pCalllogListByNumber != null)
1075         {
1076                 return __pCalllogListByNumber->GetCount();
1077         }
1078         return 0;
1079 }
1080
1081 void
1082 CallLogManager::SortCalllogList(void)
1083 {
1084         LogListComparer cmp;
1085         if(__pCalllogGroupList != null)
1086         {
1087                 ArrayList* pCalllogList = null;
1088                 GroupItemClass* pGroupInfo = null;
1089                 for(int index = 0; index < __pCalllogGroupList->GetCount(); index++)
1090                 {
1091                         pGroupInfo = static_cast<GroupItemClass*>(__pCalllogGroupList->GetAt(index));
1092                         if(pGroupInfo != null)
1093                         {
1094                                 pCalllogList = pGroupInfo->GetLogData();
1095                                 if(pCalllogList != null)
1096                                 {
1097                                         pCalllogList->Sort(cmp);
1098                                 }
1099
1100                         }
1101                 }
1102
1103         }
1104 \r
1105 }
1106
1107 void
1108 CallLogManager::SortCalllogListByNumber(void)
1109 {
1110         LogListByNumberComparer cmp;
1111         __pCalllogListByNumber->Sort(cmp);
1112 }
1113
1114 String*
1115 CallLogManager::GetLatestCallLogFromDbN(void)
1116 {
1117         String* latestNumber = null;
1118         bool found = false;
1119         if(__bDbDirty == true)
1120         {
1121                 AppLogDebug("__bDbDirty == true");
1122                 UpdateCallLogList();
1123         }
1124         if (__pCalllogGroupList != null)\r
1125         {
1126                 GroupItemClass* pGroupInfo;\r
1127                 CallLogDetails* pLatestCallLog;\r
1128                 ArrayList* callLogList;\r
1129                 int groupCount = __pCalllogGroupList->GetCount();\r
1130                 int count;\r
1131                 for(int index = 0; index < groupCount; index++)\r
1132                 {
1133                         found = false;
1134                         pGroupInfo = static_cast<GroupItemClass*>(__pCalllogGroupList->GetAt(index));\r
1135                         callLogList = pGroupInfo->GetLogData();\r
1136                         count = callLogList->GetCount();\r
1137                         for(int i = 0; i < count; i++)\r
1138                         {
1139                                 pLatestCallLog = static_cast<CallLogDetails*>(callLogList->GetAt(i));\r
1140                                 latestNumber = new String(pLatestCallLog->GetPhoneNumber());\r
1141                                 if(CheckNumberIsValid(*latestNumber))
1142                                 {
1143                                         found = true;
1144                                         break;
1145                                 }
1146                                 else
1147                                 {
1148                                         latestNumber = null;
1149                                 }
1150                         }
1151                         if(found == true)
1152                         {
1153                                 break;
1154                         }
1155                 }
1156         }
1157
1158         return latestNumber;
1159 }
1160
1161 bool
1162 CallLogManager::CheckNumberIsValid(String phoneNumber)
1163 {
1164         //Pattern to compare all characters except 0-9 * # P ; , +
1165         String phoneNumberPattern(L"[^0-9*#P,p+;]");
1166         RegularExpression checkPhoneNumber;
1167         checkPhoneNumber.Construct(phoneNumberPattern);
1168         //If there is any character other than these listed above then display invalid number
1169         bool resultMatch = checkPhoneNumber.Match(phoneNumber,false);
1170         //return false for patterns other than 0-9 * # P ; , +
1171         if(resultMatch == true)
1172         {
1173                 //return phone number is invalid
1174                 return false;
1175         }
1176
1177         return true;
1178
1179 }
1180
1181 ArrayList* CallLogManager::GetCallLogGroups()\r
1182 {
1183         return __pCalllogGroupList;\r
1184 }
1185
1186 void CallLogManager::AddCalllogChangeListener(ICalllogChangeListener& listner )
1187 {
1188         if(!__pCalllogChangeListerners->Contains(&listner))
1189         __pCalllogChangeListerners->Add(&listner);
1190
1191 }
1192
1193 void CallLogManager::RemoveCalllogChangeListner(ICalllogChangeListener& listner)
1194 {
1195         __pCalllogChangeListerners->Remove(&listner);
1196 }
1197
1198 void CallLogManager::GetCalllogContactName(String number,String& name)
1199 {
1200
1201         ByteBuffer* pByteBuffer;
1202         char * charname=NULL;
1203         pByteBuffer = StringUtil::StringToUtf8N(number);
1204
1205         contacts_filter_h filter=NULL;
1206         contacts_list_h list=NULL;
1207         contacts_query_h query = NULL;
1208         unsigned int count = 0;
1209
1210         if(number.Contains(L"@"))
1211         {
1212                 contacts_filter_create(_contacts_contact_email._uri,&filter);
1213                 contacts_filter_add_str(filter,_contacts_contact_email.email,CONTACTS_MATCH_EXACTLY,(const char*)pByteBuffer->GetPointer());
1214                 contacts_query_create(_contacts_contact_email._uri,&query);
1215                 contacts_query_set_filter(query,filter);
1216         }
1217         else
1218         {
1219                 contacts_filter_create(_contacts_contact_number._uri,&filter);
1220                 contacts_filter_add_str(filter,_contacts_contact_number.number,CONTACTS_MATCH_EXACTLY,(const char*)pByteBuffer->GetPointer());
1221                 contacts_query_create(_contacts_contact_number._uri,&query);
1222                 contacts_query_set_filter(query,filter);
1223         }
1224
1225         int ret = contacts_db_get_records_with_query(query,0,0,&list);
1226         if (ret != 0)
1227         {
1228                 contacts_filter_destroy(filter);
1229                 contacts_query_destroy(query);
1230                 return ;
1231         }
1232
1233         contacts_filter_destroy(filter);
1234         contacts_query_destroy(query);
1235
1236
1237         contacts_list_get_count(list,&count);
1238         AppLogDebug("%d",count);
1239         if(count > 0)
1240         {
1241                 contacts_record_h getrec=0;
1242                 contacts_list_first(list);
1243                 contacts_list_get_current_record_p(list,&getrec);
1244
1245                 contacts_record_get_str(getrec,_contacts_contact_number.display_name,&charname);
1246                 AppLogDebug("%s",charname);
1247                 if(charname)
1248                 {
1249                         String buffer(charname);
1250                         name.Clear();
1251                         name.Append(buffer);
1252
1253                 }
1254                 contacts_record_destroy(getrec,true);
1255         }
1256         delete pByteBuffer;
1257 }
1258
1259 void CallLogManager::ContactsDbchangedcb(const char* view_uri, void* user_data)
1260 {
1261         AppLogDebug("Enter");
1262         CallLogManager* pCallLogMgr = (CallLogManager*) user_data;
1263         if(pCallLogMgr == null || view_uri == null)
1264         {
1265                 AppLogDebug("return");
1266                 return;
1267         }
1268
1269         if(String(view_uri).Equals(String(_contacts_phone_log._uri)) == true)
1270         {
1271                 pCallLogMgr->ResetAndNotifyCalllogData();
1272         }
1273 }
1274
1275 void
1276 CallLogManager::UpDateMissedCallSeenStatus(CallLogDetails* pDetails)
1277 {
1278         contacts_record_h record;
1279         int res = contacts_db_get_record(_contacts_phone_log._uri, pDetails->GetCalllogDbId(), &record);
1280         if(res == CONTACTS_ERROR_NONE)
1281         {
1282                 if(pDetails->GetCalllogType() == CALL_LOG_TYPE_VOICE_MISSED_UNSEEN)
1283                 {
1284                         contacts_record_set_int(record,_contacts_phone_log.log_type,CONTACTS_PLOG_TYPE_VOICE_INCOMMING_SEEN);
1285                         pDetails->SetCalllogType(CONTACTS_PLOG_TYPE_VOICE_INCOMMING_SEEN);
1286                         res = contacts_db_update_record(record);
1287                         AppLogDebug("contacts_db_update_record %d",res);
1288                 }
1289         }
1290 }\r
1291
1292 void\r
1293 CallLogManager::setCallLogViewbyID(CallLogType id)\r
1294 {\r
1295         __callLogViewbyID = id;\r
1296 }\r
1297
1298 CallLogType\r
1299 CallLogManager::getCallLogViewbyID()\r
1300 {\r
1301         return __callLogViewbyID;\r
1302 }
1303 \r
1304 contacts_phone_log_type_e\r
1305 CallLogManager::GetCallLogType(CallLogType type)\r
1306 {\r
1307         contacts_phone_log_type_e callLogType =  CONTACTS_PLOG_TYPE_MAX;\r
1308         switch (type)\r
1309         {\r
1310         case CALL_LOG_TYPE_VOICE_INCOMING:\r
1311                 callLogType = CONTACTS_PLOG_TYPE_VOICE_INCOMMING;\r
1312                 break;\r
1313 \r
1314         case CALL_LOG_TYPE_VOICE_OUTGOING:\r
1315                         callLogType = CONTACTS_PLOG_TYPE_VOICE_OUTGOING;\r
1316                         break;\r
1317 \r
1318         case CALL_LOG_TYPE_VOICE_MISSED:\r
1319                         callLogType = CONTACTS_PLOG_TYPE_VOICE_INCOMMING_SEEN;\r
1320                         break;\r
1321 \r
1322         case CALL_LOG_TYPE_VOICE_MISSED_UNSEEN:\r
1323                         callLogType = CONTACTS_PLOG_TYPE_VOICE_INCOMMING_UNSEEN;\r
1324                         break;\r
1325 \r
1326         case CALL_LOG_TYPE_VOICE_REJECTED:\r
1327                         callLogType = CONTACTS_PLOG_TYPE_VOICE_REJECT;\r
1328                         break;\r
1329 \r
1330         case CALL_LOG_TYPE_VOICE_BLOCKED:\r
1331                         callLogType = CONTACTS_PLOG_TYPE_VOICE_BLOCKED;\r
1332                         break;\r
1333 \r
1334         default:\r
1335                 break;\r
1336         }\r
1337 \r
1338         return callLogType;\r
1339 }\r
1340 \r
1341 GroupItemClass::GroupItemClass()\r
1342 {\r
1343         __pData = null;\r
1344 }\r
1345 \r
1346 GroupItemClass::~GroupItemClass()\r
1347 {\r
1348         /*if(__pData)\r
1349         {\r
1350                 delete __pData;\r
1351         }*/\r
1352 }\r
1353 \r
1354 void\r
1355 GroupItemClass::SetTitleText(String titleText)\r
1356 {\r
1357         __titleText = titleText;\r
1358 }\r
1359 \r
1360 void\r
1361 GroupItemClass::SetLogData(ArrayList* pData)\r
1362 {\r
1363         __pData = pData;\r
1364 }\r
1365 \r
1366 String\r
1367 GroupItemClass::GetTitleText(void)\r
1368 {\r
1369         return __titleText;\r
1370 }\r
1371 \r
1372 ArrayList*\r
1373 GroupItemClass::GetLogData(void)\r
1374 {\r
1375         return __pData;\r
1376 }\r
1377 \r
1378