src/FScl_PersonImpl.cpp

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