include/account_PG.h

   1 /*
   2  * Account
   3  *
   4  * Copyright (c) 2010 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Wonyoung Lee <wy1115.lee@samsung.com>, Tarun Kumar <tarun.kr@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       printf("(%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        printf("(%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       printf("(%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       printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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            printf("(%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            printf("(%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        printf("(%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        printf("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 191    }
 192
 193    ret = account_disconnect();
 194    if(ret != ACCOUNT_ERROR_NONE)
 195    {
 196        printf("(%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(account_capability_type_e capability_type, account_capability_state_e capability_value, void* user_data)
 207 {
 208    int test_type = capability_type;
 209    int test_value = capability_value;
 210
 211    printf("_capability_get_callback test_type = : %d\n", test_type);
 212    printf("_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            printf("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 233    }
 234
 235    ret = account_create(&account);
 236    if(ret != ACCOUNT_ERROR_NONE)
 237    {
 238            printf("(%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            printf("(%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    printf("_account_get_callback : %s\n", test_text);
 251
 252    _account_free_text(test_text);
 253
 254    account_get_display_name(handle, &test_text);
 255    printf("_account_get_callback : %s\n", test_text);
 256
 257    _account_free_text(test_text);
 258
 259    account_get_email_address(handle, &test_text);
 260    printf("_account_get_callback : %s\n", test_text);
 261
 262    _account_free_text(test_text);
 263
 264    account_get_icon_path(handle, &test_text);
 265    printf("_account_get_callback : %s\n", test_text);
 266
 267    _account_free_text(test_text);
 268
 269    account_get_source(handle, &test_text);
 270    printf("_account_get_callback : %s\n", test_text);
 271
 272    _account_free_text(test_text);
 273
 274    account_get_package_name(handle, &test_text);
 275    printf("_account_get_callback : %s\n", test_text);
 276
 277    _account_free_text(test_text);
 278
 279    account_get_domain_name(handle, &test_text);
 280    printf("_account_get_callback : %s\n", test_text);
 281
 282    _account_free_text(test_text);
 283
 284    account_get_access_token(handle, &test_text);
 285    printf("_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            printf("_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    printf("account_get_auth_type : %d\n", auth_type);
 302
 303    account_secrecy_state_e secret;
 304    account_get_secret(handle, &secret);
 305    printf("account_get_secret : %d\n", secret);
 306
 307    account_sync_state_e sync_support;
 308    account_get_sync_support(handle, &sync_support);
 309    printf("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            printf("_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            printf("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 324    }
 325
 326    ret = account_disconnect();
 327    if(ret != ACCOUNT_ERROR_NONE)
 328    {
 329            printf("(%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    printf("_account_get_callback\n");
 349
 350    char *test_text = NULL;
 351
 352    account_get_user_name(handle, &test_text);
 353    printf("_account_get_callback : %s\n", test_text);
 354
 355    _account_free_text(test_text);
 356
 357    account_get_display_name(handle, &test_text);
 358    printf("_account_get_callback : %s\n", test_text);
 359
 360    _account_free_text(test_text);
 361
 362    account_get_email_address(handle, &test_text);
 363    printf("_account_get_callback : %s\n", test_text);
 364
 365    _account_free_text(test_text);
 366
 367    account_get_icon_path(handle, &test_text);
 368    printf("_account_get_callback : %s\n", test_text);
 369
 370    _account_free_text(test_text);
 371
 372    account_get_source(handle, &test_text);
 373    printf("_account_get_callback : %s\n", test_text);
 374
 375    _account_free_text(test_text);
 376
 377    account_get_package_name(handle, &test_text);
 378    printf("_account_get_callback : %s\n", test_text);
 379
 380    _account_free_text(test_text);
 381
 382    account_get_domain_name(handle, &test_text);
 383    printf("_account_get_callback : %s\n", test_text);
 384
 385    _account_free_text(test_text);
 386
 387    account_get_access_token(handle, &test_text);
 388    printf("_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         printf("_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    printf("account_get_auth_type : %d\n", auth_type);
 405
 406    account_secrecy_state_e secret;
 407    account_get_secret(handle, &secret);
 408    printf("account_get_secret : %d\n", secret);
 409
 410    account_sync_state_e sync_support;
 411    account_get_sync_support(handle, &sync_support);
 412    printf("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         printf("_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            printf("(%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            printf("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 442    }
 443
 444    ret = account_disconnect();
 445    if(ret != ACCOUNT_ERROR_NONE)
 446    {
 447            printf("(%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    printf("_account_get_callback\n");
 466
 467    char *test_text = NULL;
 468
 469    account_get_user_name(handle, &test_text);
 470    printf("_account_get_callback : %s\n", test_text);
 471
 472    _account_free_text(test_text);
 473
 474    account_get_display_name(handle, &test_text);
 475    printf("_account_get_callback : %s\n", test_text);
 476
 477    _account_free_text(test_text);
 478
 479    account_get_email_address(handle, &test_text);
 480    printf("_account_get_callback : %s\n", test_text);
 481
 482    _account_free_text(test_text);
 483
 484    account_get_icon_path(handle, &test_text);
 485    printf("_account_get_callback : %s\n", test_text);
 486
 487    _account_free_text(test_text);
 488
 489    account_get_source(handle, &test_text);
 490    printf("_account_get_callback : %s\n", test_text);
 491
 492    _account_free_text(test_text);
 493
 494    account_get_package_name(handle, &test_text);
 495    printf("_account_get_callback : %s\n", test_text);
 496
 497    _account_free_text(test_text);
 498
 499    account_get_domain_name(handle, &test_text);
 500    printf("_account_get_callback : %s\n", test_text);
 501
 502    _account_free_text(test_text);
 503
 504    account_get_access_token(handle, &test_text);
 505    printf("_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         printf("_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    printf("account_get_auth_type : %d\n", auth_type);
 522
 523    account_secrecy_state_e secret;
 524    account_get_secret(handle, &secret);
 525    printf("account_get_secret : %d\n", secret);
 526
 527    account_sync_state_e sync_support;
 528    account_get_sync_support(handle, &sync_support);
 529    printf("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         printf("_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            printf("(%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            printf("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 558    }
 559
 560    ret = account_disconnect();
 561    if(ret != ACCOUNT_ERROR_NONE)
 562    {
 563            printf("(%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    printf("_account_get_callback\n");
 582
 583    char *test_text = NULL;
 584
 585    account_get_user_name(handle, &test_text);
 586    printf("_account_get_callback : %s\n", test_text);
 587
 588    _account_free_text(test_text);
 589
 590    account_get_display_name(handle, &test_text);
 591    printf("_account_get_callback : %s\n", test_text);
 592
 593    _account_free_text(test_text);
 594
 595    account_get_email_address(handle, &test_text);
 596    printf("_account_get_callback : %s\n", test_text);
 597
 598    _account_free_text(test_text);
 599
 600    account_get_icon_path(handle, &test_text);
 601    printf("_account_get_callback : %s\n", test_text);
 602
 603    _account_free_text(test_text);
 604
 605    account_get_source(handle, &test_text);
 606    printf("_account_get_callback : %s\n", test_text);
 607
 608    _account_free_text(test_text);
 609
 610    account_get_package_name(handle, &test_text);
 611    printf("_account_get_callback : %s\n", test_text);
 612
 613    _account_free_text(test_text);
 614
 615    account_get_domain_name(handle, &test_text);
 616    printf("_account_get_callback : %s\n", test_text);
 617
 618    _account_free_text(test_text);
 619
 620    account_get_access_token(handle, &test_text);
 621    printf("_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         printf("_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    printf("account_get_auth_type : %d\n", auth_type);
 638
 639    account_secrecy_state_e secret;
 640    account_get_secret(handle, &secret);
 641    printf("account_get_secret : %d\n", secret);
 642
 643    account_sync_state_e sync_support;
 644    account_get_sync_support(handle, &sync_support);
 645    printf("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         printf("_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            printf("(%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            printf("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 674    }
 675
 676    ret = account_disconnect();
 677    if(ret != ACCOUNT_ERROR_NONE)
 678    {
 679            printf("(%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       printf("(%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       printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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            printf("(%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            printf("(%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        printf("(%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        printf("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 801    }
 802
 803    ret = account_disconnect();
 804    if(ret != ACCOUNT_ERROR_NONE)
 805    {
 806        printf("(%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       printf("(%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       printf("(%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       printf("(%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       printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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        printf("(%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            printf("(%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            printf("(%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            printf("(%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            printf("(%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        printf("(%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       printf("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account);
 932    }
 933
 934    ret = account_disconnect();
 935    if(ret != ACCOUNT_ERROR_NONE)
 936    {
 937       printf("(%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            printf("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 953    }
 954
 955    ret = account_delete(account_id);
 956    if(ret != ACCOUNT_ERROR_NONE)
 957    {
 958            printf("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 959    }
 960
 961    ret = account_disconnect();
 962    if(ret != ACCOUNT_ERROR_NONE)
 963    {
 964            printf("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 965    }
 966    return;
 967 }
 968 @endcode
 969
 970         <h2 class="pg">Delete account by user name </h2>
 971
 972 @code
 973 void delete_account_by_user_name(char *user_name, char *package_name)
 974 {
 975    int ret = -1;
 976    ret = account_connect();
 977    if(ret != ACCOUNT_ERROR_NONE)
 978    {
 979            printf("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 980    }
 981
 982    ret = account_delete_from_db_by_user_name(user_name, package_name);
 983    if(ret != ACCOUNT_ERROR_NONE)
 984    {
 985            printf("(%d)-[Account] ret = %d \n", __LINE__, ret);
 986    }
 987
 988    ret = account_disconnect();
 989    if(ret != ACCOUNT_ERROR_NONE)
 990    {
 991            printf("(%d)-[Account] ret = %d, \n", __LINE__, ret);
 992    }
 993    return;
 994 }
 995 @endcode
 996
 997         <h2 class="pg">Delete account by package name </h2>
 998
 999 @code
1000 void delete_account_by_package_name(char *package_name)
1001 {
1002    int ret = -1;
1003    ret = account_connect();
1004    if(ret != ACCOUNT_ERROR_NONE)
1005    {
1006            printf("(%d)-[Account] ret = %d, \n", __LINE__, ret);
1007    }
1008
1009    ret = account_delete_from_db_by_package_name(package_name);
1010    if(ret != ACCOUNT_ERROR_NONE)
1011    {
1012            printf("(%d)-[Account] ret = %d \n", __LINE__, ret);
1013    }
1014
1015    ret = account_disconnect();
1016    if(ret != ACCOUNT_ERROR_NONE)
1017    {
1018            printf("(%d)-[Account] ret = %d, \n", __LINE__, ret);
1019    }
1020    return;
1021 }
1022 @endcode
1023
1024         <h2 class="pg">Get account insert dbus notification </h2>
1025
1026 @code
1027 void notify_account_insert()
1028 {
1029     DBusMessage* msg;
1030     DBusConnection* conn;
1031     DBusError err;
1032
1033     printf("Listening for signals\n");
1034
1035     dbus_error_init(&err);
1036
1037     conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
1038     if  (dbus_error_is_set(&err)) {
1039              fprintf(stderr, "Connection Error (%s)\n", err.message);
1040             dbus_error_free(&err);
1041     }
1042     if (NULL == conn) {
1043             exit(1);
1044     }
1045
1046     dbus_bus_add_match(conn, "type='signal',interface='account.signal.Type'", &err);
1047     dbus_connection_flush(conn);
1048     if  (dbus_error_is_set(&err)) {
1049             fprintf(stderr, "Match Error (%s)\n", err.message);
1050             exit(1);
1051     }
1052     printf("Match rule sent\n");
1053
1054     while (true) {
1055
1056             dbus_connection_read_write(conn, 0);
1057             msg = dbus_connection_pop_message(conn);
1058
1059             if  (NULL == msg) {
1060                 sleep(1);
1061                 continue;
1062             }
1063
1064             if (dbus_message_is_signal(msg, ACCOUNT_DBUS_SIGNAL_INTERFACE, ACCOUNT_DBUS_NOTI_NAME_INSERT)) {
1065                   printf("Got Signal with name insert\n");
1066             }
1067
1068             dbus_message_unref(msg);
1069     }
1070     dbus_connection_close(conn);
1071 }
1072 @endcode
1073
1074         <h2 class="pg">Get account update dbus notification </h2>
1075
1076 @code
1077 void notify_account_update()
1078 {
1079     DBusMessage* msg;
1080     DBusConnection* conn;
1081     DBusError err;
1082
1083     printf("Listening for signals\n");
1084
1085
1086     dbus_error_init(&err);
1087
1088     conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
1089     if  (dbus_error_is_set(&err)) {
1090              fprintf(stderr, "Connection Error (%s)\n", err.message);
1091             dbus_error_free(&err);
1092     }
1093     if (NULL == conn) {
1094             exit(1);
1095     }
1096
1097     dbus_bus_add_match(conn, "type='signal',interface='account.signal.Type'", &err);
1098     dbus_connection_flush(conn);
1099     if  (dbus_error_is_set(&err)) {
1100             fprintf(stderr, "Match Error (%s)\n", err.message);
1101             exit(1);
1102     }
1103     printf("Match rule sent\n");
1104
1105     while (true) {
1106
1107             dbus_connection_read_write(conn, 0);
1108             msg = dbus_connection_pop_message(conn);
1109
1110             if  (NULL == msg) {
1111                 sleep(1);
1112                 continue;
1113             }
1114
1115             if (dbus_message_is_signal(msg, ACCOUNT_DBUS_SIGNAL_INTERFACE, ACCOUNT_DBUS_NOTI_NAME_UPDATE)) {
1116                 printf("Got Signal with name update\n");
1117             }
1118
1119             dbus_message_unref(msg);
1120     }
1121     dbus_connection_close(conn);
1122 }
1123 @endcode
1124
1125         <h2 class="pg">Get account delete dbus notification </h2>
1126
1127 @code
1128 void notify_account_delete()
1129 {
1130     DBusMessage* msg;
1131     DBusConnection* conn;
1132     DBusError err;
1133
1134     printf("Listening for signals\n");
1135
1136
1137     dbus_error_init(&err);
1138
1139     conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
1140     if  (dbus_error_is_set(&err)) {
1141              fprintf(stderr, "Connection Error (%s)\n", err.message);
1142             dbus_error_free(&err);
1143     }
1144     if (NULL == conn) {
1145             exit(1);
1146     }
1147
1148     dbus_bus_add_match(conn, "type='signal',interface='account.signal.Type'", &err);
1149     dbus_connection_flush(conn);
1150     if  (dbus_error_is_set(&err)) {
1151             fprintf(stderr, "Match Error (%s)\n", err.message);
1152             exit(1);
1153     }
1154     printf("Match rule sent\n");
1155
1156     while (true) {
1157
1158             dbus_connection_read_write(conn, 0);
1159             msg = dbus_connection_pop_message(conn);
1160
1161             if  (NULL == msg) {
1162                 sleep(1);
1163                 continue;
1164             }
1165
1166             if (dbus_message_is_signal(msg, ACCOUNT_DBUS_SIGNAL_INTERFACE, ACCOUNT_DBUS_NOTI_NAME_DELETE)) {
1167                 printf("Got Signal with name delete\n");
1168             }
1169
1170             dbus_message_unref(msg);
1171     }
1172     dbus_connection_close(conn);
1173 }
1174 @endcode
1175
1176         <h2 class="pg">Get capability by acccount id</h2>
1177
1178 @code
1179 bool _capability_get_callback(account_capability_type_e capability_type, account_capability_state_e capability_value, void* user_data)
1180 {
1181    int test_type = capability_type;
1182    int test_value = capability_value;
1183
1184    printf("_capability_get_callback test_type = : %d\n", test_type);
1185    printf("_capability_get_callback test_value = : %d\n", test_value);
1186    return TRUE;
1187 }
1188
1189 void capability_by_account_id(int account_id)
1190 {
1191    int ret = -1;
1192    ret = account_connect();
1193    if(ret != ACCOUNT_ERROR_NONE)
1194    {
1195            printf("(%d)-[Account] ret = %d, \n", __LINE__, ret);
1196    }
1197
1198    ret = account_query_capability_by_account_id(_capability_get_callback, account_id, NULL);
1199    if(ret != ACCOUNT_ERROR_NONE)
1200    {
1201            printf("(%d)-[Account] ret = %d \n", __LINE__, ret);
1202    }
1203
1204    ret = account_disconnect();
1205    if(ret != ACCOUNT_ERROR_NONE)
1206    {
1207            printf("(%d)-[Account] ret = %d, \n", __LINE__, ret);
1208    }
1209    return;
1210 }
1211 @endcode
1212  * @}
1213  */
1214