src/FScl_PersonImpl.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   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  * @file                FScl_PersonImpl.cpp
  18  * @brief               This is the implementation for Profile class.
  19  *
  20  * This file contains definitions of @e _PersonImpl class.
  21  */
  22
  23 #include <unique_ptr.h>
  24 #include <FBaseSysLog.h>
  25 #include <FBaseUtilStringTokenizer.h>
  26 #include <FBaseInteger.h>
  27 #include <FSclPerson.h>
  28 #include <FSclContact.h>
  29 #include <FSclCategory.h>
  30 #include <FApp_AppInfo.h>
  31 #include <FScl_ContactImpl.h>
  32 #include <FScl_CategoryImpl.h>
  33 #include <FScl_RecordImpl.h>
  34 #include "FScl_PersonImpl.h"
  35 #include "FScl_EmailImpl.h"
  36 #include "FScl_PhoneNumberImpl.h"
  37 #include "FScl_AddressbookUtil.h"
  38 #include "FScl_ContactDbConnector.h"
  39 #include "FScl_ContactDbMonitor.h"
  40
  41 using namespace Tizen::App;
  42 using namespace Tizen::Base;
  43 using namespace Tizen::Base::Collection;
  44 using namespace Tizen::Base::Utility;
  45 using namespace Tizen::Graphics;
  46 using namespace Tizen::Media;
  47
  48 namespace Tizen { namespace Social
  49 {
  50
  51 _PersonImpl::_PersonImpl()
  52 : __isFavorite(false)
  53 , __hasPhoneNumber(false)
  54 , __hasEmail(false)
  55 , __personId(-1)
  56 , __accountId1(-1)
  57 , __accountId2(-1)
  58 , __accountId3(-1)
  59 {
  60
  61 }
  62
  63 _PersonImpl::~_PersonImpl(void)
  64 {
  65
  66 }
  67
  68 bool
  69 _PersonImpl::Equals(const Object& rhs) const
  70 {
  71         const _PersonImpl* pPersonImpl = dynamic_cast<const _PersonImpl*>(&rhs);
  72         if (pPersonImpl == null)
  73         {
  74                 return false;
  75         }
  76
  77         if (__personId == pPersonImpl->__personId)
  78         {
  79                 return true;
  80         }
  81
  82         return false;
  83 }
  84
  85 int
  86 _PersonImpl::GetHashCode(void) const
  87 {
  88         return 0;
  89 }
  90
  91 void
  92 _PersonImpl::SetId(int personId)
  93 {
  94         __personId = personId;
  95 }
  96
  97 PersonId
  98 _PersonImpl::GetId(void) const
  99 {
 100         return __personId;
 101 }
 102
 103 void
 104 _PersonImpl::SetIsFavorite(bool isFavorite)
 105 {
 106         __isFavorite = isFavorite;
 107 }
 108
 109 bool
 110 _PersonImpl::IsFavorite(void) const
 111 {
 112         return __isFavorite;
 113 }
 114
 115 void
 116 _PersonImpl::SetAddressbookIdString(const String& addressbookIdString)
 117 {
 118         __addressbookIdString = addressbookIdString;
 119 }
 120
 121 void
 122 _PersonImpl::SetDisplayName(const String& displayName)
 123 {
 124         __displayName = displayName;
 125 }
 126
 127 String
 128 _PersonImpl::GetDisplayName(void) const
 129 {
 130         return __displayName;
 131 }
 132
 133 void
 134 _PersonImpl::SetThumbnailPath(const String& thumbnailPath)
 135 {
 136         __thumbnailPath = thumbnailPath;
 137 }
 138
 139 String
 140 _PersonImpl::GetThumbnailPath(void) const
 141 {
 142         return __thumbnailPath;
 143 }
 144
 145 void
 146 _PersonImpl::SetRingtonePath(const String& ringtonePath)
 147 {
 148          __ringtonePath = ringtonePath;
 149 }
 150
 151 String
 152 _PersonImpl::GetRingtonePath(void) const
 153 {
 154         return __ringtonePath;
 155 }
 156
 157 void
 158 _PersonImpl::SetHasPhoneNumber(bool hasPhoneNumber)
 159 {
 160         __hasPhoneNumber = hasPhoneNumber;
 161 }
 162
 163 bool
 164 _PersonImpl::HasPhoneNumber(void) const
 165 {
 166         return __hasPhoneNumber;
 167 }
 168
 169 void
 170 _PersonImpl::SetHasEmail(bool hasEmail)
 171 {
 172         __hasEmail = hasEmail;
 173 }
 174
 175 bool
 176 _PersonImpl::HasEmail(void) const
 177 {
 178         return __hasEmail;
 179 }
 180
 181 IListT<AccountId>*
 182 _PersonImpl::GetAccountIdsN(void) const
 183 {
 184         ClearLastResult();
 185
 186         if (__pAccountIds == null)
 187         {
 188                 _ContactDbMonitor* pContactDbMonitor = _ContactDbMonitor::GetInstance();
 189                 SysTryReturn(NID_SCL, GetLastResult() != E_OUT_OF_MEMORY, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 190                 SysTryReturn(NID_SCL, GetLastResult() == E_SUCCESS, null, E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 191
 192                 std::unique_ptr<ArrayListT<AccountId> > pAccountIdList(new (std::nothrow) ArrayListT<AccountId>());
 193                 SysTryReturn(NID_SCL, pAccountIdList != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 194
 195                 result r = pAccountIdList->Construct();
 196                 SysTryReturn(NID_SCL, r == E_SUCCESS, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 197
 198                 String delim(L" ");
 199                 StringTokenizer tokenizer(__addressbookIdString, delim);
 200                 String token;
 201                 int addressbookId = 0;
 202                 int accountId = 0;
 203
 204                 while (tokenizer.HasMoreTokens())
 205                 {
 206                         tokenizer.GetNextToken(token);
 207                         Integer::Parse(token, addressbookId);
 208                         if (addressbookId == DEFAULT_ADDRESSBOOK_ID)
 209                         {
 210                                 continue;
 211                         }
 212
 213                         accountId = pContactDbMonitor->GetAccountIdByAddressbookId(addressbookId);
 214                         SysTryReturn(NID_SCL, GetLastResult() != E_OUT_OF_MEMORY, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 215                         SysTryReturn(NID_SCL, GetLastResult() == E_SUCCESS, null, E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 216
 217                         if (accountId > 0)
 218                         {
 219                                 result r = pAccountIdList->Add(accountId);
 220                                 SysTryReturn(NID_SCL, !IsFailed(r), null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 221                         }
 222                 }
 223
 224                 __pAccountIds = std::move(pAccountIdList);
 225         }
 226
 227         std::unique_ptr<ArrayListT<AccountId> > pList(new (std::nothrow) ArrayListT<AccountId>());
 228         SysTryReturn(NID_SCL, pList != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 229
 230         result r = pList->Construct(*__pAccountIds);
 231         SysTryReturn(NID_SCL, r == E_SUCCESS, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 232
 233         return pList.release();
 234 }
 235
 236 result
 237 _PersonImpl::SetAsFavorite(bool isFavorite)
 238 {
 239         SysTryReturn(NID_SCL, _ContactDbConnector::EnsureDbConnection() == E_SUCCESS, GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 240
 241         bool boolValue = false;
 242         contacts_record_h personHandle = null;
 243
 244         int ret = contacts_db_get_record(_contacts_person._uri, __personId, &personHandle);
 245         SysTryReturn(NID_SCL, ret != CONTACTS_ERROR_OUT_OF_MEMORY, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 246         SysTryReturn(NID_SCL, ret != CONTACTS_ERROR_NO_DATA, E_OBJ_NOT_FOUND, E_OBJ_NOT_FOUND, "[%s] The person is not found.", GetErrorMessage(E_OBJ_NOT_FOUND));
 247
 248         __ContactsRecordHandle recordHandle(personHandle);
 249
 250         contacts_record_get_bool(personHandle, _contacts_person.is_favorite, &boolValue);
 251
 252         if (boolValue != isFavorite)
 253         {
 254                 contacts_record_set_bool(personHandle, _contacts_person.is_favorite, isFavorite);
 255
 256                 ret = contacts_db_update_record(personHandle);
 257                 SysTryReturn(NID_SCL, ret != CONTACTS_ERROR_OUT_OF_MEMORY, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 258                 SysTryReturn(NID_SCL, ret == CONTACTS_ERROR_NONE, E_SYSTEM, E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 259
 260                 __isFavorite = isFavorite;
 261         }
 262
 263         return E_SUCCESS;
 264 }
 265
 266 result
 267 _PersonImpl::SetAsPrimaryPhoneNumber(const PhoneNumber& phoneNumber)
 268 {
 269         int numberId = _PhoneNumberImpl::GetInstance(phoneNumber)->GetRecordId();
 270
 271         SysTryReturn(NID_SCL, numberId > 0, E_INVALID_ARG, E_INVALID_ARG, "[%s] Invalid argument is used. The specified number is invalid.", GetErrorMessage(E_INVALID_ARG));
 272         SysTryReturn(NID_SCL, _ContactDbConnector::EnsureDbConnection() == E_SUCCESS, GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 273
 274         int ret = contacts_person_set_default_property(CONTACTS_PERSON_PROPERTY_NUMBER, __personId, numberId);
 275         SysTryReturn(NID_SCL, ret != CONTACTS_ERROR_OUT_OF_MEMORY, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 276         SysTryReturn(NID_SCL, ret == CONTACTS_ERROR_NONE, E_SYSTEM, E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 277
 278         return E_SUCCESS;
 279 }
 280
 281 result
 282 _PersonImpl::SetAsPrimaryEmail(const Email& email)
 283 {
 284         int emailId = _EmailImpl::GetInstance(email)->GetRecordId();
 285
 286         SysTryReturn(NID_SCL, emailId > 0, E_INVALID_ARG, E_INVALID_ARG, "[%s] Invalid argument is used. The specified number is invalid.", GetErrorMessage(E_INVALID_ARG));
 287         SysTryReturn(NID_SCL, _ContactDbConnector::EnsureDbConnection() == E_SUCCESS, GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 288
 289         int ret = contacts_person_set_default_property(CONTACTS_PERSON_PROPERTY_EMAIL, __personId, emailId);
 290         SysTryReturn(NID_SCL, ret != CONTACTS_ERROR_OUT_OF_MEMORY, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 291         SysTryReturn(NID_SCL, ret == CONTACTS_ERROR_NONE, E_SYSTEM, E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 292
 293         return E_SUCCESS;
 294 }
 295
 296
 297 PhoneNumber
 298 _PersonImpl::GetPrimaryPhoneNumber(void) const
 299 {
 300         SysTryReturn(NID_SCL, _ContactDbConnector::EnsureDbConnection() == E_SUCCESS, PhoneNumber(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 301
 302         int intValue = 0;
 303         char* pCharValue = null;
 304         String number(L"");
 305         PhoneNumberType type = PHONENUMBER_TYPE_HOME;
 306
 307         PhoneNumber primaryPhoneNumber;
 308
 309         contacts_record_h currentHandle = null;
 310
 311         __Filter<__ContactsPersonNumber> filter;
 312         filter.Construct();
 313         filter.AddInt(_contacts_person_number.person_id, CONTACTS_MATCH_EQUAL, __personId);
 314         filter.AddOperator(CONTACTS_FILTER_OPERATOR_AND);
 315         filter.AddBool(_contacts_person_email.is_primary_default, true);
 316
 317         __Query<__ContactsPersonNumber> query;
 318         query.Construct();
 319         query.SetFilter(filter);
 320
 321         std::unique_ptr<__SearchResult<__ContactsPersonNumber> > pSearchResult(_AddressbookUtil::ExecuteQuery(query));
 322         SysTryReturn(NID_SCL, pSearchResult != null, primaryPhoneNumber, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 323
 324         if (pSearchResult->GetCount() == 0)
 325         {
 326                 return primaryPhoneNumber;
 327         }
 328
 329         while (pSearchResult->MoveNext() == E_SUCCESS)
 330         {
 331                 currentHandle = pSearchResult->GetCurrentRecord();
 332                 contacts_record_get_int(currentHandle, _contacts_person_number.number_id, &intValue);
 333
 334                 contacts_record_get_int(currentHandle, _contacts_person_number.number_id, &intValue);
 335                 _PhoneNumberImpl::GetInstance(primaryPhoneNumber)->SetRecordId(intValue);
 336
 337                 contacts_record_get_str_p(currentHandle, _contacts_person_number.label, &pCharValue);
 338                 _PhoneNumberImpl::GetInstance(primaryPhoneNumber)->SetLabel(pCharValue);
 339
 340                 contacts_record_get_int(currentHandle, _contacts_person_number.type, &intValue);
 341                 switch (intValue)
 342                 {
 343                 case CONTACTS_NUMBER_TYPE_HOME | CONTACTS_NUMBER_TYPE_VOICE:
 344                         type = PHONENUMBER_TYPE_HOME;
 345                         break;
 346                 case CONTACTS_NUMBER_TYPE_WORK | CONTACTS_NUMBER_TYPE_VOICE:
 347                         type = PHONENUMBER_TYPE_WORK;
 348                         break;
 349                 case CONTACTS_NUMBER_TYPE_CELL:
 350                         type = PHONENUMBER_TYPE_MOBILE;
 351                         break;
 352                 case CONTACTS_NUMBER_TYPE_FAX | CONTACTS_NUMBER_TYPE_HOME:
 353                         type = PHONENUMBER_TYPE_HOME_FAX;
 354                         break;
 355                 case CONTACTS_NUMBER_TYPE_FAX | CONTACTS_NUMBER_TYPE_WORK:
 356                         type = PHONENUMBER_TYPE_WORK_FAX;
 357                         break;
 358                 case CONTACTS_NUMBER_TYPE_PAGER:
 359                         type = PHONENUMBER_TYPE_PAGER;
 360                         break;
 361                 case CONTACTS_NUMBER_TYPE_CUSTOM:
 362                         type = PHONENUMBER_TYPE_CUSTOM;
 363                         break;
 364                 case CONTACTS_NUMBER_TYPE_ASSISTANT:
 365                         if (_AppInfo::GetApiVersion() < _API_VERSION_2_1)
 366                         {
 367                                 type = PHONENUMBER_TYPE_OTHER;
 368                         }
 369                         else
 370                         {
 371                                 type = PHONENUMBER_TYPE_ASSISTANT;
 372                         }
 373                         break;
 374                 default:
 375                         type = PHONENUMBER_TYPE_OTHER;
 376                         break;
 377                 }
 378
 379                 _PhoneNumberImpl::GetInstance(primaryPhoneNumber)->SetType(type);
 380
 381                 contacts_record_get_str_p(currentHandle, _contacts_person_number.number, &pCharValue);
 382                 _PhoneNumberImpl::GetInstance(primaryPhoneNumber)->SetPhoneNumber(pCharValue);
 383
 384                 break;
 385         }
 386
 387         return primaryPhoneNumber;
 388 }
 389
 390 Email
 391 _PersonImpl::GetPrimaryEmail(void) const
 392 {
 393         SysTryReturn(NID_SCL, _ContactDbConnector::EnsureDbConnection() == E_SUCCESS, Email(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 394
 395         int intValue = 0;
 396         char* pCharValue = null;
 397         EmailType type = EMAIL_TYPE_PERSONAL;
 398         String email(L"");
 399
 400         Email primaryEmail;
 401
 402         contacts_record_h currentHandle = null;
 403
 404         __Filter<__ContactsPersonEmail> filter;
 405         filter.Construct();
 406         filter.AddInt(_contacts_person_email.person_id, CONTACTS_MATCH_EQUAL, __personId);
 407         filter.AddOperator(CONTACTS_FILTER_OPERATOR_AND);
 408         filter.AddBool(_contacts_person_email.is_primary_default, true);
 409
 410         __Query<__ContactsPersonEmail> query;
 411         query.Construct();
 412         query.SetFilter(filter);
 413
 414         std::unique_ptr<__SearchResult<__ContactsPersonEmail> > pSearchResult(_AddressbookUtil::ExecuteQuery(query));
 415         SysTryReturn(NID_SCL, pSearchResult != null, primaryEmail, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 416
 417         if (pSearchResult->GetCount() == 0)
 418         {
 419                 return primaryEmail;
 420         }
 421         while (pSearchResult->MoveNext() == E_SUCCESS)
 422         {
 423                 currentHandle = pSearchResult->GetCurrentRecord();
 424
 425                 contacts_record_get_int(currentHandle, _contacts_person_email.email_id, &intValue);
 426                 _EmailImpl::GetInstance(primaryEmail)->SetRecordId(intValue);
 427
 428                 contacts_record_get_str_p(currentHandle, _contacts_person_email.label, &pCharValue);
 429                 _EmailImpl::GetInstance(primaryEmail)->SetLabel(pCharValue);
 430
 431                 contacts_record_get_int(currentHandle, _contacts_person_email.type, &intValue);
 432                 switch (intValue)
 433                 {
 434                 case CONTACTS_EMAIL_TYPE_HOME:
 435                         type = EMAIL_TYPE_PERSONAL;
 436                         break;
 437                 case CONTACTS_EMAIL_TYPE_WORK:
 438                         type = EMAIL_TYPE_WORK;
 439                         break;
 440                 case CONTACTS_EMAIL_TYPE_CUSTOM:
 441                         type = EMAIL_TYPE_CUSTOM;
 442                         break;
 443                 case CONTACTS_EMAIL_TYPE_MOBILE:
 444                         if (_AppInfo::GetApiVersion() < _API_VERSION_2_1)
 445                         {
 446                                 type = EMAIL_TYPE_OTHER;
 447                         }
 448                         else
 449                         {
 450                                 type = EMAIL_TYPE_MOBILE;
 451                         }
 452                         break;
 453                 default:
 454                         type = EMAIL_TYPE_OTHER;
 455                         break;
 456                 }
 457
 458                 _EmailImpl::GetInstance(primaryEmail)->SetType(type);
 459
 460                 contacts_record_get_str_p(currentHandle, _contacts_person_email.email, &pCharValue);
 461                 _EmailImpl::GetInstance(primaryEmail)->SetEmail(pCharValue);
 462         }
 463
 464         return primaryEmail;
 465 }
 466
 467 _PersonImpl*
 468 _PersonImpl::GetInstance(Person& person)
 469 {
 470         return person.__pPersonImpl;
 471 }
 472
 473 const _PersonImpl*
 474 _PersonImpl::GetInstance(const Person& person)
 475 {
 476         return person.__pPersonImpl;
 477 }
 478
 479 }} // Tizen::Social