include/account_PG.h

   1 /*
   2  * Account
   3  *
   4  * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Wonyoung Lee <wy1115.lee@samsung.com>, Sungchan Kim <sungchan81.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /**
  23  *
  24  * @ingroup   SLP_PG
  25  * @defgroup  Account_PG Account
  26
  27
  28 <h1 class="pg">Introduction</h1>
  29         <h2 class="pg">Purpose of this document</h2>
  30
  31 The purpose of this document is to describe how applications can use account APIs for handling Account's information. This document gives programming guidelines to application engineers and examples of using Account data.
  32
  33         <h2 class="pg">Scope</h2>
  34
  35 The scope of this document is limited to Account API usage.
  36
  37
  38 <h1 class="pg">Account Architecture</h1>
  39         <h2 class="pg"> Overview</h2>
  40
  41 Account is responsible for inserting, deleting, and updating Account data in order to accommodate the needs for application's Account data.
  42 Users can access Account data without knowing DB schema, SQLite, relations of data
  43
  44 <h1 class="pg">Account Features</h1>
  45         - Similar to Sqlite3
  46         - Handle information of Account
  47
  48         <h2 class="pg">Similar to Sqlite3</h2>
  49 Account API is similar to Sqlite3.
  50
  51         <h2 class="pg">Handle information of Account</h2>
  52 Account supports to insert/update/delete/get/set/query information of Account.
  53 The Information of Account includes user name, package name, email, access token, icon path, source, display name, capability informatio etc.
  54
  55 <h1 class="pg">Account API Description</h1>
  56
  57 you can refer @ref ACCOUNT_SVC
  58
  59 <h1 class="pg">Sample Code</h1>
  60
  61         <h2 class="pg">Connect to Account Database</h2>
  62
  63 Before using Account information from Account API, caller module should connect to the Account database, and after finishing with the account information, should disconnect from the Account database
  64
  65 @code
  66 int account_connect(void);
  67
  68 int account_disconnect(void);
  69 @endcode
  70
  71         <h2 class="pg">Insert information of account</h2>
  72
  73 @code
  74 void insert_test(void)
  75 {
  76    int ret = -1;
  77    account_h account;
  78
  79    ret = account_connect();
  80    if(ret != ACCOUNT_ERROR_NONE)
  81    {
  82       SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
  83    }
  84
  85    ret = account_create(&account);
  86    if(ret != ACCOUNT_ERROR_NONE)
  87    {
  88        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
  89    }
  90
  91    ret = account_set_user_name(account, "tarun.kr");
  92
  93    if(ret != ACCOUNT_ERROR_NONE)
  94    {
  95       SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
  96    }
  97
  98    ret = account_set_display_name(account, "Tarun Kumar");
  99
 100    if(ret != ACCOUNT_ERROR_NONE)
 101    {
 102       SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 103    }
 104
 105    ret = account_set_domain_name(account, "Samsung electronics");
 106    if(ret != ACCOUNT_ERROR_NONE)
 107    {
 108        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 109    }
 110
 111    ret = account_set_email_address(account, "tarun@gmail.com");
 112    if(ret != ACCOUNT_ERROR_NONE)
 113    {
 114        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 115    }
 116
 117    ret = account_set_package_name(account, "com.samsung.twiter");
 118    if(ret != ACCOUNT_ERROR_NONE)
 119    {
 120        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 121    }
 122
 123    ret = account_set_icon_path(account, "icon-path");
 124    if(ret != ACCOUNT_ERROR_NONE)
 125    {
 126        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 127    }
 128
 129    ret = account_set_access_token(account, "ACCESSTOKEN");
 130    if(ret != ACCOUNT_ERROR_NONE)
 131    {
 132        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 133    }
 134
 135    ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH );
 136    if(ret != ACCOUNT_ERROR_NONE)
 137    {
 138        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 139    }
 140
 141    ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE );
 142    if(ret != ACCOUNT_ERROR_NONE)
 143    {
 144        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 145    }
 146    ret = account_set_source(account, "URUSA inc.");
 147
 148    int i;
 149
 150    for(i=0;i<USER_TXT_CNT;i++)
 151    {
 152        ret = account_set_user_text(account, i, "user txt");
 153        if(ret != ACCOUNT_ERROR_NONE)
 154        {
 155            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i);
 156        }
 157
 158    }
 159
 160    for(i=0;i<USER_INT_CNT;i++)
 161    {
 162        ret = account_set_user_int(account, i, 888);
 163        if(ret != ACCOUNT_ERROR_NONE)
 164        {
 165            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i);
 166        }
 167    }
 168
 169    ret = account_set_capability(account, ACCOUNT_CAPABILITY_CONTACT, ACCOUNT_CAPABILITY_ENABLED);
 170    ret = account_set_capability(account, ACCOUNT_CAPABILITY_CALENDAR, ACCOUNT_CAPABILITY_ENABLED);
 171    ret = account_set_capability(account, ACCOUNT_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_ENABLED);
 172    ret = account_set_capability(account, ACCOUNT_CAPABILITY_VIDEO, ACCOUNT_CAPABILITY_ENABLED);
 173    ret = account_set_capability(account, ACCOUNT_CAPABILITY_EMAIL, ACCOUNT_CAPABILITY_ENABLED);
 174    ret = account_set_capability(account, ACCOUNT_CAPABILITY_STATUS_POST, ACCOUNT_CAPABILITY_ENABLED);
 175    ret = account_set_capability(account, ACCOUNT_CAPABILITY_VOIP, ACCOUNT_CAPABILITY_ENABLED);
 176    ret = account_set_capability(account, ACCOUNT_CAPABILITY_SAMSUNG_APPS, ACCOUNT_CAPABILITY_ENABLED);
 177    ret = account_set_capability(account, ACCOUNT_CAPABILITY_MOBILE_TRACKER, ACCOUNT_CAPABILITY_ENABLED);
 178
 179    int account_id = -1;
 180    ret = account_insert_to_db(account, &account_id);
 181    if(ret != ACCOUNT_ERROR_NONE)
 182    {
 183        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 184        return;
 185    }
 186
 187    ret = account_destroy(account);
 188    if(ret != ACCOUNT_ERROR_NONE)
 189    {
 190        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 191    }
 192
 193    ret = account_disconnect();
 194    if(ret != ACCOUNT_ERROR_NONE)
 195    {
 196        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 197    }
 198
 199    return;
 200 }
 201 @endcode
 202
 203         <h2 class="pg">Get account by id</h2>
 204
 205 @code
 206 bool _capability_get_callback(const char* capability_type, account_capability_state_e capability_value, void* user_data)
 207 {
 208    char* test_type = capability_type;
 209    int test_value = capability_value;
 210
 211    SECURE_LOGD("_capability_get_callback test_type = : %s\n", test_type);
 212    SECURE_LOGD("_capability_get_callback test_value = : %d\n", test_value);
 213    return TRUE;
 214 }
 215
 216 static void _account_free_text(char *text)
 217 {
 218         if (text) {
 219                 free(text);
 220                 text = NULL;
 221         }
 222 }
 223
 224 void get_account_by_id(int account_id)
 225 {
 226    int ret = - 1;
 227    account_h account;
 228
 229    ret = account_connect();
 230    if(ret != ACCOUNT_ERROR_NONE)
 231    {
 232            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 233    }
 234
 235    ret = account_create(&account);
 236    if(ret != ACCOUNT_ERROR_NONE)
 237    {
 238            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 239    }
 240
 241    ret = account_query_account_by_account_id(account_id, &account);
 242    if(ret != ACCOUNT_ERROR_NONE)
 243    {
 244            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 245    }
 246
 247    char *test_text = NULL;
 248
 249    account_get_user_name(handle, &test_text);
 250    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 251
 252    _account_free_text(test_text);
 253
 254    account_get_display_name(handle, &test_text);
 255    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 256
 257    _account_free_text(test_text);
 258
 259    account_get_email_address(handle, &test_text);
 260    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 261
 262    _account_free_text(test_text);
 263
 264    account_get_icon_path(handle, &test_text);
 265    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 266
 267    _account_free_text(test_text);
 268
 269    account_get_source(handle, &test_text);
 270    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 271
 272    _account_free_text(test_text);
 273
 274    account_get_package_name(handle, &test_text);
 275    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 276
 277    _account_free_text(test_text);
 278
 279    account_get_domain_name(handle, &test_text);
 280    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 281
 282    _account_free_text(test_text);
 283
 284    account_get_access_token(handle, &test_text);
 285    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 286
 287    int i;
 288
 289    for(i=0;i<USER_TXT_CNT;i++)
 290    {
 291            _account_free_text(test_text);
 292
 293            account_get_user_text(handle, i, &test_text);
 294            SECURE_LOGD("_account_get_callback : %s\n", test_text);
 295    }
 296
 297    int test_int  = -1;
 298
 299    account_auth_type_e auth_type;
 300    account_get_auth_type(handle, &auth_type);
 301    SECURE_LOGD("account_get_auth_type : %d\n", auth_type);
 302
 303    account_secrecy_state_e secret;
 304    account_get_secret(handle, &secret);
 305    SECURE_LOGD("account_get_secret : %d\n", secret);
 306
 307    account_sync_state_e sync_support;
 308    account_get_sync_support(handle, &sync_support);
 309    SECURE_LOGD("account_get_sync_support : %d\n", sync_support);
 310
 311    for(i=0;i<USER_INT_CNT;i++)
 312    {
 313            test_int  = -1;
 314            account_get_user_int(handle, i, &test_int);
 315            SECURE_LOGD("_account_get_callback : %d\n", test_int);
 316    }
 317
 318    account_get_capability(handle, _capability_get_callback, NULL);
 319
 320    ret = account_destroy(account);
 321    if(ret != ACCOUNT_ERROR_NONE)
 322    {
 323            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 324    }
 325
 326    ret = account_disconnect();
 327    if(ret != ACCOUNT_ERROR_NONE)
 328    {
 329            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 330    }
 331 }
 332 @endcode
 333
 334
 335         <h2 class="pg">Get account list by user name</h2>
 336
 337 @code
 338 static void _account_free_text(char *text)
 339 {
 340         if (text) {
 341                 free(text);
 342                 text = NULL;
 343         }
 344 }
 345
 346 bool _account_get_callback(account_h handle, void* user_data)
 347 {
 348    SECURE_LOGD("_account_get_callback\n");
 349
 350    char *test_text = NULL;
 351
 352    account_get_user_name(handle, &test_text);
 353    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 354
 355    _account_free_text(test_text);
 356
 357    account_get_display_name(handle, &test_text);
 358    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 359
 360    _account_free_text(test_text);
 361
 362    account_get_email_address(handle, &test_text);
 363    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 364
 365    _account_free_text(test_text);
 366
 367    account_get_icon_path(handle, &test_text);
 368    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 369
 370    _account_free_text(test_text);
 371
 372    account_get_source(handle, &test_text);
 373    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 374
 375    _account_free_text(test_text);
 376
 377    account_get_package_name(handle, &test_text);
 378    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 379
 380    _account_free_text(test_text);
 381
 382    account_get_domain_name(handle, &test_text);
 383    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 384
 385    _account_free_text(test_text);
 386
 387    account_get_access_token(handle, &test_text);
 388    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 389
 390    int i;
 391
 392    for(i=0;i<USER_TXT_CNT;i++)
 393    {
 394         _account_free_text(test_text);
 395
 396         account_get_user_text(handle, i, &test_text);
 397         SECURE_LOGD("_account_get_callback : %s\n", test_text);
 398    }
 399
 400    int test_int  = -1;
 401
 402    account_auth_type_e auth_type;
 403    account_get_auth_type(handle, &auth_type);
 404    SECURE_LOGD("account_get_auth_type : %d\n", auth_type);
 405
 406    account_secrecy_state_e secret;
 407    account_get_secret(handle, &secret);
 408    SECURE_LOGD("account_get_secret : %d\n", secret);
 409
 410    account_sync_state_e sync_support;
 411    account_get_sync_support(handle, &sync_support);
 412    SECURE_LOGD("account_get_sync_support : %d\n", sync_support);
 413
 414    for(i=0;i<USER_INT_CNT;i++)
 415    {
 416         test_int  = -1;
 417         account_get_user_int(handle, i, &test_int);
 418         SECURE_LOGD("_account_get_callback : %d\n", test_int);
 419    }
 420
 421    account_get_capability(handle, _capability_get_callback, NULL);
 422
 423    return TRUE;
 424 }
 425
 426
 427 void get_account_list_by_user_name(char * user_name)
 428 {
 429    int ret = - 1;
 430    account_h account;
 431
 432    ret = account_connect();
 433    if(ret != ACCOUNT_ERROR_NONE)
 434    {
 435            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 436    }
 437
 438    ret = account_query_account_by_user_name(_account_get_callback, user_name, NULL);
 439    if(ret != ACCOUNT_ERROR_NONE)
 440    {
 441            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 442    }
 443
 444    ret = account_disconnect();
 445    if(ret != ACCOUNT_ERROR_NONE)
 446    {
 447            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 448    }
 449 }
 450 @endcode
 451
 452         <h2 class="pg">Get account list by package name</h2>
 453
 454 @code
 455 static void _account_free_text(char *text)
 456 {
 457         if (text) {
 458                 free(text);
 459                 text = NULL;
 460         }
 461 }
 462
 463 bool _account_get_callback(account_h handle, void* user_data)
 464 {
 465    SECURE_LOGD("_account_get_callback\n");
 466
 467    char *test_text = NULL;
 468
 469    account_get_user_name(handle, &test_text);
 470    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 471
 472    _account_free_text(test_text);
 473
 474    account_get_display_name(handle, &test_text);
 475    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 476
 477    _account_free_text(test_text);
 478
 479    account_get_email_address(handle, &test_text);
 480    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 481
 482    _account_free_text(test_text);
 483
 484    account_get_icon_path(handle, &test_text);
 485    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 486
 487    _account_free_text(test_text);
 488
 489    account_get_source(handle, &test_text);
 490    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 491
 492    _account_free_text(test_text);
 493
 494    account_get_package_name(handle, &test_text);
 495    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 496
 497    _account_free_text(test_text);
 498
 499    account_get_domain_name(handle, &test_text);
 500    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 501
 502    _account_free_text(test_text);
 503
 504    account_get_access_token(handle, &test_text);
 505    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 506
 507    int i;
 508
 509    for(i=0;i<USER_TXT_CNT;i++)
 510    {
 511            _account_free_text(test_text);
 512
 513         account_get_user_text(handle, i, &test_text);
 514         SECURE_LOGD("_account_get_callback : %s\n", test_text);
 515    }
 516
 517    int test_int  = -1;
 518
 519    account_auth_type_e auth_type;
 520    account_get_auth_type(handle, &auth_type);
 521    SECURE_LOGD("account_get_auth_type : %d\n", auth_type);
 522
 523    account_secrecy_state_e secret;
 524    account_get_secret(handle, &secret);
 525    SECURE_LOGD("account_get_secret : %d\n", secret);
 526
 527    account_sync_state_e sync_support;
 528    account_get_sync_support(handle, &sync_support);
 529    SECURE_LOGD("account_get_sync_support : %d\n", sync_support);
 530
 531    for(i=0;i<USER_INT_CNT;i++)
 532    {
 533         test_int  = -1;
 534         account_get_user_int(handle, i, &test_int);
 535         SECURE_LOGD("_account_get_callback : %d\n", test_int);
 536    }
 537
 538    account_get_capability(handle, _capability_get_callback, NULL);
 539
 540    return TRUE;
 541 }
 542
 543 void get_account_list_by_package_name(char * package_name)
 544 {
 545    int ret = - 1;
 546    account_h account;
 547
 548    ret = account_connect();
 549    if(ret != ACCOUNT_ERROR_NONE)
 550    {
 551            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 552    }
 553
 554    ret = account_query_account_by_package_name(_account_get_callback, package_name, NULL);
 555    if(ret != ACCOUNT_ERROR_NONE)
 556    {
 557            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 558    }
 559
 560    ret = account_disconnect();
 561    if(ret != ACCOUNT_ERROR_NONE)
 562    {
 563            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 564    }
 565 }
 566 @endcode
 567
 568         <h2 class="pg">Get all account list</h2>
 569
 570 @code
 571 static void _account_free_text(char *text)
 572 {
 573         if (text) {
 574                 free(text);
 575                 text = NULL;
 576         }
 577 }
 578
 579 bool _account_get_callback(account_h handle, void* user_data)
 580 {
 581    SECURE_LOGD("_account_get_callback\n");
 582
 583    char *test_text = NULL;
 584
 585    account_get_user_name(handle, &test_text);
 586    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 587
 588    _account_free_text(test_text);
 589
 590    account_get_display_name(handle, &test_text);
 591    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 592
 593    _account_free_text(test_text);
 594
 595    account_get_email_address(handle, &test_text);
 596    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 597
 598    _account_free_text(test_text);
 599
 600    account_get_icon_path(handle, &test_text);
 601    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 602
 603    _account_free_text(test_text);
 604
 605    account_get_source(handle, &test_text);
 606    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 607
 608    _account_free_text(test_text);
 609
 610    account_get_package_name(handle, &test_text);
 611    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 612
 613    _account_free_text(test_text);
 614
 615    account_get_domain_name(handle, &test_text);
 616    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 617
 618    _account_free_text(test_text);
 619
 620    account_get_access_token(handle, &test_text);
 621    SECURE_LOGD("_account_get_callback : %s\n", test_text);
 622
 623    int i;
 624
 625    for(i=0;i<USER_TXT_CNT;i++)
 626    {
 627         _account_free_text(test_text);
 628
 629         account_get_user_text(handle, i, &test_text);
 630         SECURE_LOGD("_account_get_callback : %s\n", test_text);
 631    }
 632
 633    int test_int  = -1;
 634
 635    account_auth_type_e auth_type;
 636    account_get_auth_type(handle, &auth_type);
 637    SECURE_LOGD("account_get_auth_type : %d\n", auth_type);
 638
 639    account_secrecy_state_e secret;
 640    account_get_secret(handle, &secret);
 641    SECURE_LOGD("account_get_secret : %d\n", secret);
 642
 643    account_sync_state_e sync_support;
 644    account_get_sync_support(handle, &sync_support);
 645    SECURE_LOGD("account_get_sync_support : %d\n", sync_support);
 646
 647    for(i=0;i<USER_INT_CNT;i++)
 648    {
 649         test_int  = -1;
 650         account_get_user_int(handle, i, &test_int);
 651         SECURE_LOGD("_account_get_callback : %d\n", test_int);
 652    }
 653
 654    account_get_capability(handle, _capability_get_callback, NULL);
 655
 656    return TRUE;
 657 }
 658
 659 void get_all_account()
 660 {
 661    int ret = - 1;
 662    account_h account;
 663
 664    ret = account_connect();
 665    if(ret != ACCOUNT_ERROR_NONE)
 666    {
 667            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 668    }
 669
 670    ret = account_foreach_account_from_db(_account_get_callback, NULL);
 671    if(ret != ACCOUNT_ERROR_NONE)
 672    {
 673            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 674    }
 675
 676    ret = account_disconnect();
 677    if(ret != ACCOUNT_ERROR_NONE)
 678    {
 679            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 680    }
 681 }
 682 @endcode
 683
 684         <h2 class="pg">Update information of account by account id</h2>
 685
 686 @code
 687 void update_accont_by_id(int account_id)
 688 {
 689    int ret = -1;
 690    account_h account;
 691
 692    ret = account_connect();
 693    if(ret != ACCOUNT_ERROR_NONE)
 694    {
 695       SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 696    }
 697
 698    ret = account_create(&account);
 699    if(ret != ACCOUNT_ERROR_NONE)
 700    {
 701       SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 702    }
 703
 704    ret = account_set_user_name(account, "update-tarun.kr");
 705
 706    if(ret != ACCOUNT_ERROR_NONE)
 707    {
 708        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 709    }
 710
 711    ret = account_set_display_name(account, "update-Tarun Kumar");
 712    if(ret != ACCOUNT_ERROR_NONE)
 713    {
 714        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 715    }
 716
 717    ret = account_set_domain_name(account, "update-Samsung electronics");
 718    if(ret != ACCOUNT_ERROR_NONE)
 719    {
 720        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 721    }
 722
 723    ret = account_set_email_address(account, "update-tarun@gmail.com");
 724    if(ret != ACCOUNT_ERROR_NONE)
 725    {
 726        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 727    }
 728
 729    ret = account_set_package_name(account, "update-com.samsung.twiter");
 730    if(ret != ACCOUNT_ERROR_NONE)
 731    {
 732        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 733    }
 734
 735    ret = account_set_icon_path(account, "update-icon-path");
 736    if(ret != ACCOUNT_ERROR_NONE)
 737    {
 738        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 739    }
 740
 741    ret = account_set_access_token(account, "update-ACCESSTOKEN");
 742    if(ret != ACCOUNT_ERROR_NONE)
 743    {
 744        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 745    }
 746
 747    ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH );
 748    if(ret != ACCOUNT_ERROR_NONE)
 749    {
 750        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 751    }
 752    ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE );
 753    if(ret != ACCOUNT_ERROR_NONE)
 754    {
 755        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 756    }
 757    ret = account_set_source(account, "update-URUSA inc.");
 758
 759    int i;
 760
 761    for(i=0;i<USER_TXT_CNT;i++)
 762    {
 763        ret = account_set_user_text(account, i, "update-user txt");
 764        if(ret != ACCOUNT_ERROR_NONE)
 765        {
 766            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i);
 767        }
 768
 769    }
 770
 771    for(i=0;i<USER_INT_CNT;i++)
 772    {
 773        ret = account_set_user_int(account, i, 999);
 774        if(ret != ACCOUNT_ERROR_NONE)
 775        {
 776            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i);
 777        }
 778    }
 779
 780    ret = account_set_capability(account, ACCOUNT_CAPABILITY_CONTACT, ACCOUNT_CAPABILITY_DISABLED);
 781    ret = account_set_capability(account, ACCOUNT_CAPABILITY_CALENDAR, ACCOUNT_CAPABILITY_DISABLED);
 782    ret = account_set_capability(account, ACCOUNT_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_DISABLED);
 783    ret = account_set_capability(account, ACCOUNT_CAPABILITY_VIDEO, ACCOUNT_CAPABILITY_DISABLED);
 784    ret = account_set_capability(account, ACCOUNT_CAPABILITY_EMAIL, ACCOUNT_CAPABILITY_DISABLED);
 785    ret = account_set_capability(account, ACCOUNT_CAPABILITY_STATUS_POST, ACCOUNT_CAPABILITY_DISABLED);
 786    ret = account_set_capability(account, ACCOUNT_CAPABILITY_VOIP, ACCOUNT_CAPABILITY_DISABLED);
 787    ret = account_set_capability(account, ACCOUNT_CAPABILITY_SAMSUNG_APPS, ACCOUNT_CAPABILITY_DISABLED);
 788    ret = account_set_capability(account, ACCOUNT_CAPABILITY_MOBILE_TRACKER, ACCOUNT_CAPABILITY_DISABLED);
 789
 790    ret = account_update_to_db_by_id(account, account_id);
 791    if(ret != ACCOUNT_ERROR_NONE)
 792    {
 793        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 794        return;
 795    }
 796
 797    ret = account_destroy(account);
 798    if(ret != ACCOUNT_ERROR_NONE)
 799    {
 800        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 801    }
 802
 803    ret = account_disconnect();
 804    if(ret != ACCOUNT_ERROR_NONE)
 805    {
 806        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 807    }
 808 }
 809 @endcode
 810
 811         <h2 class="pg">Update information of account by user name</h2>
 812
 813 @code
 814 void update_accont_by_user_name(char *user_name, char *package_name)
 815 {
 816    int ret = -1;
 817    account_h account;
 818
 819    ret = account_connect();
 820    if(ret != ACCOUNT_ERROR_NONE)
 821    {
 822       SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 823    }
 824
 825    ret = account_create(&account);
 826    if(ret != ACCOUNT_ERROR_NONE)
 827    {
 828       SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 829    }
 830
 831    ret = account_set_user_name(account, "update-tarun.kr");
 832    if(ret != ACCOUNT_ERROR_NONE)
 833    {
 834       SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 835    }
 836
 837    ret = account_set_display_name(account, "update-Tarun Kumar");
 838    if(ret != ACCOUNT_ERROR_NONE)
 839    {
 840       SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 841    }
 842
 843    ret = account_set_domain_name(account, "update-Samsung electronics");
 844    if(ret != ACCOUNT_ERROR_NONE)
 845    {
 846        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 847    }
 848
 849    ret = account_set_email_address(account, "update-tarun@gmail.com");
 850    if(ret != ACCOUNT_ERROR_NONE)
 851    {
 852        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 853    }
 854
 855    ret = account_set_package_name(account, "update-com.samsung.twiter");
 856    if(ret != ACCOUNT_ERROR_NONE)
 857    {
 858        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 859    }
 860
 861    ret = account_set_icon_path(account, "update-icon-path");
 862    if(ret != ACCOUNT_ERROR_NONE)
 863    {
 864        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 865    }
 866
 867    ret = account_set_access_token(account, "update-ACCESSTOKEN");
 868    if(ret != ACCOUNT_ERROR_NONE)
 869    {
 870        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 871    }
 872
 873    ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH );
 874    if(ret != ACCOUNT_ERROR_NONE)
 875    {
 876        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 877    }
 878    ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE );
 879    if(ret != ACCOUNT_ERROR_NONE)
 880    {
 881            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 882    }
 883
 884    ret = account_set_source(account, "update-URUSA inc.");
 885    if(ret != ACCOUNT_ERROR_NONE)
 886    {
 887            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 888    }
 889
 890    int i;
 891
 892    for(i=0;i<USER_TXT_CNT;i++)
 893    {
 894        ret = account_set_user_text(account, i, "update-user txt");
 895        if(ret != ACCOUNT_ERROR_NONE)
 896        {
 897            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i);
 898        }
 899
 900    }
 901
 902    for(i=0;i<USER_INT_CNT;i++)
 903    {
 904        ret = account_set_user_int(account, i, 999);
 905        if(ret != ACCOUNT_ERROR_NONE)
 906        {
 907            SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i);
 908        }
 909    }
 910
 911    ret = account_set_capability(account, ACCOUNT_CAPABILITY_CONTACT, ACCOUNT_CAPABILITY_DISABLED);
 912    ret = account_set_capability(account, ACCOUNT_CAPABILITY_CALENDAR, ACCOUNT_CAPABILITY_DISABLED);
 913    ret = account_set_capability(account, ACCOUNT_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_DISABLED);
 914    ret = account_set_capability(account, ACCOUNT_CAPABILITY_VIDEO, ACCOUNT_CAPABILITY_DISABLED);
 915    ret = account_set_capability(account, ACCOUNT_CAPABILITY_EMAIL, ACCOUNT_CAPABILITY_DISABLED);
 916    ret = account_set_capability(account, ACCOUNT_CAPABILITY_STATUS_POST, ACCOUNT_CAPABILITY_DISABLED);
 917    ret = account_set_capability(account, ACCOUNT_CAPABILITY_VOIP, ACCOUNT_CAPABILITY_DISABLED);
 918    ret = account_set_capability(account, ACCOUNT_CAPABILITY_SAMSUNG_APPS, ACCOUNT_CAPABILITY_DISABLED);
 919    ret = account_set_capability(account, ACCOUNT_CAPABILITY_MOBILE_TRACKER, ACCOUNT_CAPABILITY_DISABLED);
 920
 921    ret = account_update_to_db_by_user_name(account, user_name, package_name);
 922    if(ret != ACCOUNT_ERROR_NONE)
 923    {
 924        SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 925        return;
 926    }
 927
 928    ret = account_destroy(account);
 929    if(ret != ACCOUNT_ERROR_NONE)
 930    {
 931       SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 932    }
 933
 934    ret = account_disconnect();
 935    if(ret != ACCOUNT_ERROR_NONE)
 936    {
 937       SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 938    }
 939 }
 940 @endcode
 941
 942         <h2 class="pg">Delete account by id </h2>
 943
 944 @code
 945 void delete_account_by_id(int account_id)
 946 {
 947    int ret = -1;
 948
 949    ret = account_connect();
 950    if(ret != ACCOUNT_ERROR_NONE)
 951    {
 952            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 953    }
 954
 955    ret = account_delete(account_id);
 956    if(ret != ACCOUNT_ERROR_NONE)
 957    {
 958            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 959    }
 960
 961    ret = account_disconnect();
 962    if(ret != ACCOUNT_ERROR_NONE)
 963    {
 964            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 965    }
 966    return;
 967 }
 968 @endcode
 969
 970         <h2 class="pg">Update sync status by id </h2>
 971
 972 @code
 973 void update_sync_status_by_id(int account_id, const account_sync_state_e sync_status)
 974 {
 975    int ret = -1;
 976
 977    ret = account_connect();
 978    if(ret != ACCOUNT_ERROR_NONE)
 979    {
 980            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 981    }
 982
 983    ret = account_update_sync_status_by_id(account_id, sync_status);
 984    if(ret != ACCOUNT_ERROR_NONE)
 985    {
 986            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 987    }
 988
 989    ret = account_disconnect();
 990    if(ret != ACCOUNT_ERROR_NONE)
 991    {
 992            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 993    }
 994    return;
 995 }
 996 @endcode
 997
 998         <h2 class="pg">Delete account by user name </h2>
 999
1000 @code
1001 void delete_account_by_user_name(char *user_name, char *package_name)
1002 {
1003    int ret = -1;
1004    ret = account_connect();
1005    if(ret != ACCOUNT_ERROR_NONE)
1006    {
1007            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
1008    }
1009
1010    ret = account_delete_from_db_by_user_name(user_name, package_name);
1011    if(ret != ACCOUNT_ERROR_NONE)
1012    {
1013            SECURE_LOGD("(%d)-[Account] ret = %d \n", __LINE__, ret);
1014    }
1015
1016    ret = account_disconnect();
1017    if(ret != ACCOUNT_ERROR_NONE)
1018    {
1019            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
1020    }
1021    return;
1022 }
1023 @endcode
1024
1025         <h2 class="pg">Delete account by package name </h2>
1026
1027 @code
1028 void delete_account_by_package_name(char *package_name)
1029 {
1030    int ret = -1;
1031    ret = account_connect();
1032    if(ret != ACCOUNT_ERROR_NONE)
1033    {
1034            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
1035    }
1036
1037    ret = account_delete_from_db_by_package_name(package_name);
1038    if(ret != ACCOUNT_ERROR_NONE)
1039    {
1040            SECURE_LOGD("(%d)-[Account] ret = %d \n", __LINE__, ret);
1041    }
1042
1043    ret = account_disconnect();
1044    if(ret != ACCOUNT_ERROR_NONE)
1045    {
1046            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
1047    }
1048    return;
1049 }
1050 @endcode
1051
1052         <h2 class="pg">Get account insert dbus notification </h2>
1053
1054 @code
1055 void notify_account_insert()
1056 {
1057     DBusMessage* msg;
1058     DBusConnection* conn;
1059     DBusError err;
1060
1061     SECURE_LOGD("Listening for signals\n");
1062
1063     dbus_error_init(&err);
1064
1065     conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
1066     if  (dbus_error_is_set(&err)) {
1067             dbus_error_free(&err);
1068     }
1069     if (NULL == conn) {
1070             exit(1);
1071     }
1072
1073     dbus_bus_add_match(conn, "type='signal',interface='account.signal.Type'", &err);
1074     dbus_connection_flush(conn);
1075     if  (dbus_error_is_set(&err)) {
1076             exit(1);
1077     }
1078     SECURE_LOGD("Match rule sent\n");
1079
1080     while (true) {
1081
1082             dbus_connection_read_write(conn, 0);
1083             msg = dbus_connection_pop_message(conn);
1084
1085             if  (NULL == msg) {
1086                 sleep(1);
1087                 continue;
1088             }
1089
1090             if (dbus_message_is_signal(msg, ACCOUNT_DBUS_SIGNAL_INTERFACE, ACCOUNT_DBUS_NOTI_NAME_INSERT)) {
1091                   SECURE_LOGD("Got Signal with name insert\n");
1092             }
1093
1094             dbus_message_unref(msg);
1095     }
1096     dbus_connection_close(conn);
1097 }
1098 @endcode
1099
1100         <h2 class="pg">Get account update dbus notification </h2>
1101
1102 @code
1103 void notify_account_update()
1104 {
1105     DBusMessage* msg;
1106     DBusConnection* conn;
1107     DBusError err;
1108
1109     SECURE_LOGD("Listening for signals\n");
1110
1111
1112     dbus_error_init(&err);
1113
1114     conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
1115     if  (dbus_error_is_set(&err)) {
1116             dbus_error_free(&err);
1117     }
1118     if (NULL == conn) {
1119             exit(1);
1120     }
1121
1122     dbus_bus_add_match(conn, "type='signal',interface='account.signal.Type'", &err);
1123     dbus_connection_flush(conn);
1124     if  (dbus_error_is_set(&err)) {
1125             exit(1);
1126     }
1127     SECURE_LOGD("Match rule sent\n");
1128
1129     while (true) {
1130
1131             dbus_connection_read_write(conn, 0);
1132             msg = dbus_connection_pop_message(conn);
1133
1134             if  (NULL == msg) {
1135                 sleep(1);
1136                 continue;
1137             }
1138
1139             if (dbus_message_is_signal(msg, ACCOUNT_DBUS_SIGNAL_INTERFACE, ACCOUNT_DBUS_NOTI_NAME_UPDATE)) {
1140                 SECURE_LOGD("Got Signal with name update\n");
1141             }
1142
1143             dbus_message_unref(msg);
1144     }
1145     dbus_connection_close(conn);
1146 }
1147 @endcode
1148
1149         <h2 class="pg">Get account delete dbus notification </h2>
1150
1151 @code
1152 void notify_account_delete()
1153 {
1154     DBusMessage* msg;
1155     DBusConnection* conn;
1156     DBusError err;
1157
1158     SECURE_LOGD("Listening for signals\n");
1159
1160
1161     dbus_error_init(&err);
1162
1163     conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
1164     if  (dbus_error_is_set(&err)) {
1165             dbus_error_free(&err);
1166     }
1167     if (NULL == conn) {
1168             exit(1);
1169     }
1170
1171     dbus_bus_add_match(conn, "type='signal',interface='account.signal.Type'", &err);
1172     dbus_connection_flush(conn);
1173     if  (dbus_error_is_set(&err)) {
1174             exit(1);
1175     }
1176     SECURE_LOGD("Match rule sent\n");
1177
1178     while (true) {
1179
1180             dbus_connection_read_write(conn, 0);
1181             msg = dbus_connection_pop_message(conn);
1182
1183             if  (NULL == msg) {
1184                 sleep(1);
1185                 continue;
1186             }
1187
1188             if (dbus_message_is_signal(msg, ACCOUNT_DBUS_SIGNAL_INTERFACE, ACCOUNT_DBUS_NOTI_NAME_DELETE)) {
1189                 SECURE_LOGD("Got Signal with name delete\n");
1190             }
1191
1192             dbus_message_unref(msg);
1193     }
1194     dbus_connection_close(conn);
1195 }
1196 @endcode
1197
1198         <h2 class="pg">Get capability by acccount id</h2>
1199
1200 @code
1201 bool _capability_get_callback(const char* capability_type, account_capability_state_e capability_value, void* user_data)
1202 {
1203    char* test_type = capability_type;
1204    int test_value = capability_value;
1205
1206    SECURE_LOGD("_capability_get_callback test_type = : %s\n", test_type);
1207    SECURE_LOGD("_capability_get_callback test_value = : %d\n", test_value);
1208    return TRUE;
1209 }
1210
1211 void capability_by_account_id(int account_id)
1212 {
1213    int ret = -1;
1214    ret = account_connect();
1215    if(ret != ACCOUNT_ERROR_NONE)
1216    {
1217            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
1218    }
1219
1220    ret = account_query_capability_by_account_id(_capability_get_callback, account_id, NULL);
1221    if(ret != ACCOUNT_ERROR_NONE)
1222    {
1223            SECURE_LOGD("(%d)-[Account] ret = %d \n", __LINE__, ret);
1224    }
1225
1226    ret = account_disconnect();
1227    if(ret != ACCOUNT_ERROR_NONE)
1228    {
1229            SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret);
1230    }
1231    return;
1232 }
1233 @endcode
1234  * @}
1235  */
1236