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 std;
  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         unique_ptr<ContactRecord, ContactRecordDeleter> pPersonRecord(_AddressbookUtil::GetContactRecordN(_contacts_person._uri, __personId));
 243         SysTryReturn(NID_SCL, pPersonRecord != null, GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 244
 245         bool boolValue = false;
 246         contacts_record_get_bool(pPersonRecord.get(), _contacts_person.is_favorite, &boolValue);
 247
 248         if (boolValue != isFavorite)
 249         {
 250                 contacts_record_set_bool(pPersonRecord.get(), _contacts_person.is_favorite, isFavorite);
 251
 252                 result r = _AddressbookUtil::UpdateContactRecord(pPersonRecord.get());
 253                 SysTryReturn(NID_SCL, !IsFailed(r), r, r, "[%s] Propagating.", GetErrorMessage(r));
 254
 255                 __isFavorite = isFavorite;
 256         }
 257
 258         return E_SUCCESS;
 259 }
 260
 261 result
 262 _PersonImpl::SetAsPrimaryPhoneNumber(const PhoneNumber& phoneNumber)
 263 {
 264         int numberId = _PhoneNumberImpl::GetInstance(phoneNumber)->GetRecordId();
 265
 266         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));
 267         SysTryReturn(NID_SCL, _ContactDbConnector::EnsureDbConnection() == E_SUCCESS, GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 268
 269         int ret = contacts_person_set_default_property(CONTACTS_PERSON_PROPERTY_NUMBER, __personId, numberId);
 270         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));
 271         SysTryReturn(NID_SCL, ret == CONTACTS_ERROR_NONE, E_SYSTEM, E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 272
 273         return E_SUCCESS;
 274 }
 275
 276 result
 277 _PersonImpl::SetAsPrimaryEmail(const Email& email)
 278 {
 279         int emailId = _EmailImpl::GetInstance(email)->GetRecordId();
 280
 281         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));
 282         SysTryReturn(NID_SCL, _ContactDbConnector::EnsureDbConnection() == E_SUCCESS, GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 283
 284         int ret = contacts_person_set_default_property(CONTACTS_PERSON_PROPERTY_EMAIL, __personId, emailId);
 285         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));
 286         SysTryReturn(NID_SCL, ret == CONTACTS_ERROR_NONE, E_SYSTEM, E_SYSTEM, "[%s] A system error has been occurred.", GetErrorMessage(E_SYSTEM));
 287
 288         return E_SUCCESS;
 289 }
 290
 291
 292 PhoneNumber
 293 _PersonImpl::GetPrimaryPhoneNumber(void) const
 294 {
 295         SysTryReturn(NID_SCL, _ContactDbConnector::EnsureDbConnection() == E_SUCCESS, PhoneNumber(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 296
 297         int intValue = 0;
 298         char* pCharValue = null;
 299         String number(L"");
 300         PhoneNumberType type = PHONENUMBER_TYPE_HOME;
 301
 302         PhoneNumber primaryPhoneNumber;
 303
 304         contacts_record_h currentHandle = null;
 305
 306         __Filter<__ContactsPersonNumber> filter;
 307         filter.Construct();
 308         filter.AddInt(_contacts_person_number.person_id, CONTACTS_MATCH_EQUAL, __personId);
 309         filter.AddOperator(CONTACTS_FILTER_OPERATOR_AND);
 310         filter.AddBool(_contacts_person_email.is_primary_default, true);
 311
 312         __Query<__ContactsPersonNumber> query;
 313         query.Construct();
 314         query.SetFilter(filter);
 315
 316         std::unique_ptr<__SearchResult<__ContactsPersonNumber> > pSearchResult(_AddressbookUtil::ExecuteQuery(query));
 317         SysTryReturn(NID_SCL, pSearchResult != null, primaryPhoneNumber, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 318
 319         if (pSearchResult->GetCount() == 0)
 320         {
 321                 return primaryPhoneNumber;
 322         }
 323
 324         while (pSearchResult->MoveNext() == E_SUCCESS)
 325         {
 326                 currentHandle = pSearchResult->GetCurrentRecord();
 327                 contacts_record_get_int(currentHandle, _contacts_person_number.number_id, &intValue);
 328
 329                 contacts_record_get_int(currentHandle, _contacts_person_number.number_id, &intValue);
 330                 _PhoneNumberImpl::GetInstance(primaryPhoneNumber)->SetRecordId(intValue);
 331
 332                 contacts_record_get_str_p(currentHandle, _contacts_person_number.label, &pCharValue);
 333                 _PhoneNumberImpl::GetInstance(primaryPhoneNumber)->SetLabel(pCharValue);
 334
 335                 contacts_record_get_int(currentHandle, _contacts_person_number.type, &intValue);
 336                 switch (intValue)
 337                 {
 338                 case CONTACTS_NUMBER_TYPE_HOME | CONTACTS_NUMBER_TYPE_VOICE:
 339                         type = PHONENUMBER_TYPE_HOME;
 340                         break;
 341                 case CONTACTS_NUMBER_TYPE_WORK | CONTACTS_NUMBER_TYPE_VOICE:
 342                         type = PHONENUMBER_TYPE_WORK;
 343                         break;
 344                 case CONTACTS_NUMBER_TYPE_CELL:
 345                         type = PHONENUMBER_TYPE_MOBILE;
 346                         break;
 347                 case CONTACTS_NUMBER_TYPE_FAX | CONTACTS_NUMBER_TYPE_HOME:
 348                         type = PHONENUMBER_TYPE_HOME_FAX;
 349                         break;
 350                 case CONTACTS_NUMBER_TYPE_FAX | CONTACTS_NUMBER_TYPE_WORK:
 351                         type = PHONENUMBER_TYPE_WORK_FAX;
 352                         break;
 353                 case CONTACTS_NUMBER_TYPE_PAGER:
 354                         type = PHONENUMBER_TYPE_PAGER;
 355                         break;
 356                 case CONTACTS_NUMBER_TYPE_CUSTOM:
 357                         type = PHONENUMBER_TYPE_CUSTOM;
 358                         break;
 359                 case CONTACTS_NUMBER_TYPE_ASSISTANT:
 360                         if (_AppInfo::GetApiVersion() < _API_VERSION_2_1)
 361                         {
 362                                 type = PHONENUMBER_TYPE_OTHER;
 363                         }
 364                         else
 365                         {
 366                                 type = PHONENUMBER_TYPE_ASSISTANT;
 367                         }
 368                         break;
 369                 default:
 370                         type = PHONENUMBER_TYPE_OTHER;
 371                         break;
 372                 }
 373
 374                 _PhoneNumberImpl::GetInstance(primaryPhoneNumber)->SetType(type);
 375
 376                 contacts_record_get_str_p(currentHandle, _contacts_person_number.number, &pCharValue);
 377                 _PhoneNumberImpl::GetInstance(primaryPhoneNumber)->SetPhoneNumber(pCharValue);
 378
 379                 break;
 380         }
 381
 382         return primaryPhoneNumber;
 383 }
 384
 385 Email
 386 _PersonImpl::GetPrimaryEmail(void) const
 387 {
 388         SysTryReturn(NID_SCL, _ContactDbConnector::EnsureDbConnection() == E_SUCCESS, Email(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 389
 390         int intValue = 0;
 391         char* pCharValue = null;
 392         EmailType type = EMAIL_TYPE_PERSONAL;
 393         String email(L"");
 394
 395         Email primaryEmail;
 396
 397         contacts_record_h currentHandle = null;
 398
 399         __Filter<__ContactsPersonEmail> filter;
 400         filter.Construct();
 401         filter.AddInt(_contacts_person_email.person_id, CONTACTS_MATCH_EQUAL, __personId);
 402         filter.AddOperator(CONTACTS_FILTER_OPERATOR_AND);
 403         filter.AddBool(_contacts_person_email.is_primary_default, true);
 404
 405         __Query<__ContactsPersonEmail> query;
 406         query.Construct();
 407         query.SetFilter(filter);
 408
 409         std::unique_ptr<__SearchResult<__ContactsPersonEmail> > pSearchResult(_AddressbookUtil::ExecuteQuery(query));
 410         SysTryReturn(NID_SCL, pSearchResult != null, primaryEmail, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 411
 412         if (pSearchResult->GetCount() == 0)
 413         {
 414                 return primaryEmail;
 415         }
 416         while (pSearchResult->MoveNext() == E_SUCCESS)
 417         {
 418                 currentHandle = pSearchResult->GetCurrentRecord();
 419
 420                 contacts_record_get_int(currentHandle, _contacts_person_email.email_id, &intValue);
 421                 _EmailImpl::GetInstance(primaryEmail)->SetRecordId(intValue);
 422
 423                 contacts_record_get_str_p(currentHandle, _contacts_person_email.label, &pCharValue);
 424                 _EmailImpl::GetInstance(primaryEmail)->SetLabel(pCharValue);
 425
 426                 contacts_record_get_int(currentHandle, _contacts_person_email.type, &intValue);
 427                 switch (intValue)
 428                 {
 429                 case CONTACTS_EMAIL_TYPE_HOME:
 430                         type = EMAIL_TYPE_PERSONAL;
 431                         break;
 432                 case CONTACTS_EMAIL_TYPE_WORK:
 433                         type = EMAIL_TYPE_WORK;
 434                         break;
 435                 case CONTACTS_EMAIL_TYPE_CUSTOM:
 436                         type = EMAIL_TYPE_CUSTOM;
 437                         break;
 438                 case CONTACTS_EMAIL_TYPE_MOBILE:
 439                         if (_AppInfo::GetApiVersion() < _API_VERSION_2_1)
 440                         {
 441                                 type = EMAIL_TYPE_OTHER;
 442                         }
 443                         else
 444                         {
 445                                 type = EMAIL_TYPE_MOBILE;
 446                         }
 447                         break;
 448                 default:
 449                         type = EMAIL_TYPE_OTHER;
 450                         break;
 451                 }
 452
 453                 _EmailImpl::GetInstance(primaryEmail)->SetType(type);
 454
 455                 contacts_record_get_str_p(currentHandle, _contacts_person_email.email, &pCharValue);
 456                 _EmailImpl::GetInstance(primaryEmail)->SetEmail(pCharValue);
 457         }
 458
 459         return primaryEmail;
 460 }
 461
 462 _PersonImpl*
 463 _PersonImpl::GetInstance(Person& person)
 464 {
 465         return person.__pPersonImpl;
 466 }
 467
 468 const _PersonImpl*
 469 _PersonImpl::GetInstance(const Person& person)
 470 {
 471         return person.__pPersonImpl;
 472 }
 473
 474 }} // Tizen::Social