diff options
| -rwxr-xr-x | AUTHORS | 2 | ||||
| -rwxr-xr-x | CMakeLists.txt | 48 | ||||
| -rwxr-xr-x | INSTALL | 33 | ||||
| -rwxr-xr-x | LICENSE | 206 | ||||
| -rwxr-xr-x | accounts-svc.pc.in | 13 | ||||
| -rw-r--r-- | doc/account_manager_doc.h | 44 | ||||
| -rwxr-xr-x | include/account-error.h | 79 | ||||
| -rwxr-xr-x | include/account-private.h | 383 | ||||
| -rwxr-xr-x | include/account-types.h | 261 | ||||
| -rwxr-xr-x | include/account.h | 2036 | ||||
| -rwxr-xr-x | include/account_PG.h | 1236 | ||||
| -rw-r--r-- | include/account_internal.h | 81 | ||||
| -rwxr-xr-x | libaccounts-svc.manifest | 19 | ||||
| -rwxr-xr-x | packaging/libaccounts-svc.spec | 115 | ||||
| -rwxr-xr-x | src/account.c | 7345 | ||||
| -rwxr-xr-x | src/utc-account.c | 8276 |
16 files changed, 20177 insertions, 0 deletions
@@ -0,0 +1,2 @@ +Wonyoung Lee <wy1115.lee@samsung.com> +Sungchan Kim <sungchan81.kim@samsung.com> diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100755 index 0000000..80e0958 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,48 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(accounts-svc C) + +SET(PREFIX ${CMAKE_INSTALL_PREFIX}) +SET(EXEC_PREFIX "\${prefix}") +SET(LIBDIR "\${prefix}/lib") +SET(INCLUDEDIR "\${prefix}/include ") +SET(VERSION_MAJOR 0) +SET(VERSION "${VERSION_MAJOR}.2.97") + +SET(SRCS +src/account.c +) + +INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include) + +INCLUDE(FindPkgConfig) +pkg_check_modules(pkgs REQUIRED sqlite3 dlog db-util glib-2.0 capi-base-common vconf pkgmgr-info aul libsmack) + +FOREACH(flag ${pkgs_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Wall") +SET(CMAKE_LDFLAGS "-Wl,-zdefs") + +ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"") +ADD_DEFINITIONS("-DFACTORYFS=\"$ENV{FACTORYFS}\"") +ADD_DEFINITIONS("-DSLP_DEBUG") + +ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS}) +SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES SOVERSION ${VERSION_MAJOR}) +SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES VERSION ${VERSION}) + +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS}) + +CONFIGURE_FILE(${PROJECT_NAME}.pc.in ${PROJECT_NAME}.pc @ONLY) + +INSTALL(TARGETS ${PROJECT_NAME} DESTINATION lib/accounts-svc) +INSTALL(TARGETS ${PROJECT_NAME} DESTINATION lib) +INSTALL(FILES ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.pc DESTINATION lib/pkgconfig) + +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/account.h DESTINATION include) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/account-error.h DESTINATION include) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/account-types.h DESTINATION include) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/account_internal.h DESTINATION include) + +#ADD_SUBDIRECTORY(test) @@ -0,0 +1,33 @@ +1. make the build directory + + ex) + + $ mkdir build + + +2. change the working directory to the build directory + + ex) + + $ cd build + + +3. run 'cmake' + + $ cmake ${SOURCE_DIR} -DCMAKE_INSTALL_PREFIX=/usr + + ex) + + $ cmake .. -DCMAKE_INSTALL_PREFIX=/usr + + or + + $ cmake .. + + +4. make & make install + + ex) + + $ make -j 2 && make install + @@ -0,0 +1,206 @@ +Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + + diff --git a/accounts-svc.pc.in b/accounts-svc.pc.in new file mode 100755 index 0000000..969d7bb --- /dev/null +++ b/accounts-svc.pc.in @@ -0,0 +1,13 @@ +# Package Information for pkg-config + +prefix=@PREFIX@ +exec_prefix=@EXEC_PREFIX@ +libdir=@LIBDIR@ +includedir=@INCLUDEDIR@ + +Name: accounts-svc +Description: Account DB library +Version: @VERSION@ +Requires: capi-base-common +Libs: -L${libdir} -laccounts-svc +Cflags: -I${includedir} diff --git a/doc/account_manager_doc.h b/doc/account_manager_doc.h new file mode 100644 index 0000000..68d9ce3 --- /dev/null +++ b/doc/account_manager_doc.h @@ -0,0 +1,44 @@ +/* + * + * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Wonyoung Lee <wy1115.lee@samsung.com>, Sungchan Kim <sungchan81.kim@samsung.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef __ACCOUNT_H__ +#define __ACCOUNT_H__ + +/** + * @defgroup CAPI_ACCOUNT_MANAGER_MODULE Account Manager + * @ingroup CAPI_SOCIAL_FRAMEWORK + * @brief The account APIs provide CRUD (Create, Read, Update, Delete) account management functionality. + * + * @section CAPI_ACCOUNT_MANAGER_HEADER Required Header + * \#include <account.h> + * + * @section CAPI_ACCOUNT_MANAGER_MODULE_OVERVIEW Overview + * The account APIs is separated into two major sections: + * 1. Registering an account provider while an application is installed. This information will be used for the Add account screen. + * 2. Adding an account information when an application signs in successfully to share the account information to the Tizen system. This information will be shown in the Tizen settings account menu. + + * The APIs of both of the sections consist of the following functionality: + * - Create an account or account provider + * - Update an account or account provider(Only available for the creator) + * - Delete an account or account provider(Only available for the creator) + * - Read an account or account provider with some filter +*/ + +#endif /* __ACCOUNT_H__ */ diff --git a/include/account-error.h b/include/account-error.h new file mode 100755 index 0000000..592b214 --- /dev/null +++ b/include/account-error.h @@ -0,0 +1,79 @@ +/* + * + * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Wonyoung Lee <wy1115.lee@samsung.com>, Sungchan Kim <sungchan81.kim@samsung.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef __ACCOUNT_ERROR_H__ +#define __ACCOUNT_ERROR_H__ + +#include <tizen.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** + * @addtogroup CAPI_ACCOUNT_MANAGER_MODULE + * @{ + */ + +/** + * @file account-error.h + * @brief This file contains ACCOUNT error definitions. + */ + +//#define TIZEN_ERROR_ACCOUNT_CLASS SLP_ERROR_ACCOUNT | 0x90 + +/** + * @brief Enumerations of error codes for ACCOUNT APIs. + * @since_tizen 2.3 + */ +typedef enum +{ + ACCOUNT_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ + ACCOUNT_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ + ACCOUNT_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ + + ACCOUNT_ERROR_DUPLICATED = TIZEN_ERROR_ACCOUNT | 0x01, /**< Same user name exists in your application */ + ACCOUNT_ERROR_NO_DATA = TIZEN_ERROR_NO_DATA, /**< Empty data */ + + ACCOUNT_ERROR_RECORD_NOT_FOUND = TIZEN_ERROR_ACCOUNT | 0x03, /**< Related record does not exist */ + ACCOUNT_ERROR_DB_FAILED = TIZEN_ERROR_ACCOUNT | 0x04, /**< DB operation failed */ + ACCOUNT_ERROR_DB_NOT_OPENED = TIZEN_ERROR_ACCOUNT | 0x05, /**< DB is not connected */ + ACCOUNT_ERROR_QUERY_SYNTAX_ERROR = TIZEN_ERROR_ACCOUNT | 0x06, /**< DB query syntax error */ + ACCOUNT_ERROR_ITERATOR_END = TIZEN_ERROR_ACCOUNT | 0x07, /**< Iterator has reached the end */ + ACCOUNT_ERROR_NOTI_FAILED = TIZEN_ERROR_ACCOUNT | 0x08, /**< Notification failed */ + ACCOUNT_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ + ACCOUNT_ERROR_XML_PARSE_FAILED = TIZEN_ERROR_ACCOUNT | 0x0a, /**< XML parse failed */ + ACCOUNT_ERROR_XML_FILE_NOT_FOUND = TIZEN_ERROR_ACCOUNT | 0x0b, /**< XML file does not exist */ + ACCOUNT_ERROR_EVENT_SUBSCRIPTION_FAIL = TIZEN_ERROR_ACCOUNT | 0x0c, /**< Subscription failed */ + ACCOUNT_ERROR_NOT_REGISTERED_PROVIDER = TIZEN_ERROR_ACCOUNT | 0x0d, /**< Account provider is not registered */ + ACCOUNT_ERROR_NOT_ALLOW_MULTIPLE = TIZEN_ERROR_ACCOUNT | 0x0e, /**< Multiple accounts are not supported */ + ACCOUNT_ERROR_DATABASE_BUSY = TIZEN_ERROR_ACCOUNT | 0x10, /**< SQLite busy handler expired */ +} account_error_e; + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* __ACCOUNT_ERROR_H__*/ diff --git a/include/account-private.h b/include/account-private.h new file mode 100755 index 0000000..766faef --- /dev/null +++ b/include/account-private.h @@ -0,0 +1,383 @@ +/* + * account + * + * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Wonyoung Lee <wy1115.lee@samsung.com>, Sungchan Kim <sungchan81.kim@samsung.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef __ACCOUNT_PRIVATE_TYPES_H__ +#define __ACCOUNT_PRIVATE_TYPES_H__ + + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include <glib.h> +#include <dlog.h> + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + +#define LOG_TAG "ACCOUNT" + +#define ACCOUNT_VERBOSE(fmt, arg...) \ + LOGD(": " fmt "\n", ##arg); +#define ACCOUNT_DEBUG(fmt, arg...) \ + LOGD(": " fmt "\n", ##arg); +#define ACCOUNT_ERROR(fmt, arg...) \ + LOGE(": " fmt "\n", ##arg); +#define ACCOUNT_FATAL(fmt, arg...) \ + LOGF(": " fmt "\n", ##arg); +#define ACCOUNT_SLOGD(fmt, arg...) \ + SECURE_LOGD(": " fmt "\n", ##arg); +#define ACCOUNT_SLOGI(fmt, arg...) \ + SECURE_LOGI(": " fmt "\n", ##arg); +#define ACCOUNT_SLOGE(fmt, arg...) \ + SECURE_LOGE(": " fmt "\n", ##arg); + +#define ACCOUNT_RETURN_VAL(eval, expr, ret_val, X)\ + if (!(eval)) \ +{\ + expr; \ + return ret_val;\ +} else {;} + +#define ACCOUNT_SNPRINTF(dest,size,format,arg...) \ + do { \ + snprintf(dest,size-1,format,##arg); \ + }while(0) + /* If the same pointer is passed to free twice, known as a double free. To avoid this, set pointers to +NULL after passing them to free: free(NULL) is safe (it does nothing). + */ + +#define ACCOUNT_MEMSET(dest,value,size) \ + do { \ + memset(dest,value,size); \ + }while(0) + +#define ACCOUNT_CATCH_ERROR(eval, expr, error_val, X) \ + if (!(eval)) \ +{\ + expr; \ + error_code = (error_val);\ + goto CATCH;\ +} else {;} + +#define _ACCOUNT_FREE(ptr) \ + if (ptr != NULL) { \ + free(ptr); \ + ptr = NULL; \ + } \ + + +#define _ACCOUNT_GFREE(ptr) \ + if (ptr != NULL) { \ + g_free(ptr); \ + ptr = NULL; \ + } \ + +#define ACCOUNT_DB_NAME "/opt/usr/dbspace/.account.db" +#define ACCOUNT_TABLE "account" +#define CAPABILITY_TABLE "capability" +#define ACCOUNT_CUSTOM_TABLE "account_custom" +#define ACCOUNT_TYPE_TABLE "account_type" +#define LABEL_TABLE "label" +#define PROVIDER_FEATURE_TABLE "provider_feature" +#define ACCOUNT_SQLITE_SEQ "sqlite_sequence" +#define ACCOUNT_SQL_LEN_MAX 1024 +#define ACCOUNT_TABLE_TOTAL_COUNT 6 + +#define FACEBOOK_PKG_NAME "com.samsung.facebook" +#define EMAIL_PKG_NAME "email-setting-efl" +#define EXCHANGE_PKG_NAME "activesync-ui" +#define IMS_SERVICE_PKG_NAME "ims-service" +#define SAMSUNGACCOUNTFRONT_PKG_NAME "com.samsung.samsung-account-front" +//#define SAMSUNGACCOUNT_PKG_NAME "gr47by21a5.SamsungAccount" +#define SAMSUNGACCOUNT_PKG_NAME "com.samsung.samsungaccount" +#define CHATON_PKG_NAME "xnq5eh9vop.ChatON" +#define DROPBOX_PKG_NAME "com.samsung.dropbox" +#define SYNCHRONISE_PKG_NAME "setting-synchronise-efl" + +#define USER_TXT_CNT 5 +#define USER_INT_CNT 5 + + +/* account uri list */ +#define ACCOUNT_DATA_SERVICE_PROVIDER "http://tizen.org/account/data/service_provider" +#define ACCOUNT_OPERATION_SIGNIN_OLD "http://tizen.org/account/operation/signin" + +// private account operation type +#define ACCOUNT_OPERATION_FMM "http://tizen.org/account/operation/fmm" +#define ACCOUNT_OPERATION_MYACCOUNT "http://tizen.org/account/operation/signin_from_myaccount" +// End of private account operation type + +#define ACCOUNT_SUPPORTS_CAPABILITY_POST "http://tizen.org/account/capability/post" +#define ACCOUNT_SUPPORTS_CAPABILITY_VOIP "http://tizen.org/account/capability/voip" +#define ACCOUNT_SUPPORTS_CAPABILITY_SAMSUNG_APPS "http://tizen.org/account/capability/samsungapps" +#define ACCOUNT_SUPPORTS_CAPABILITY_TASK "http://tizen.org/account/capability/task" +#define ACCOUNT_SUPPORTS_CAPABILITY_MOBILE_TRACKER "http://tizen.org/account/capability/mobiletracker" +#define ACCOUNT_SUPPORTS_CAPABILITY_S_NOTE "http://tizen.org/account/capability/snote" +#define ACCOUNT_SUPPORTS_CAPABILITY_GALLERY "http://tizen.org/account/capability/gallery" +#define ACCOUNT_SUPPORTS_CAPABILITY_MEMO "http://tizen.org/account/capability/memo" +#define ACCOUNT_SUPPORTS_CAPABILITY_CHAT "http://tizen.org/account/capability/chat" +#define ACCOUNT_SUPPORTS_CAPABILITY_BOOKMARK "http://tizen.org/account/capability/bookmark" +#define ACCOUNT_SUPPORTS_CAPABILITY_SYNCHRONISE "http://tizen.org/account/capability/synchronise" +#define ACCOUNT_SUPPORTS_CAPABILITY_TIZEN_EMAIL "http://tizen.org/account/capability/tizen_email" +#define ACCOUNT_SUPPORTS_CAPABILITY_INTERNET "http://tizen.org/account/capability/internet" +#define ACCOUNT_SUPPORTS_CAPABILITY_DOCOMO_SCHEDULE_MEMO "http://tizen.org/account/capability/docomo" +/* end of account uri list */ + +typedef struct _account_s +{ + int id; + char* user_name; + char* email_address; + char* display_name; + char* icon_path; + char* source; + char* package_name; + char* access_token; + char* domain_name; /*< domain name [Ex: google, facebook, twitter, samsung, ...] */ + int auth_type; + int secret; + int sync_support; + int user_data_int[USER_INT_CNT]; + char* user_data_txt[USER_TXT_CNT]; + GSList* capablity_list; + GList* account_list; + GSList* custom_list; +}account_s; + +typedef struct _capability_s +{ + int id; + char* type; + int value; + char* package_name; + char* user_name; + int account_id; +}account_capability_s; + + +typedef struct _account_custom_s +{ + int account_id; + char* app_id; + char* key; + char* value; +}account_custom_s; + +typedef struct _account_type_s +{ + int id; + char* app_id; + char* service_provider_id; + char* icon_path; + char* small_icon_path; + bool multiple_account_support; + GSList* label_list; + GList* account_type_list; + GSList* provider_feature_list; +}account_type_s; + + +typedef struct _label_s +{ + char* app_id; + char* label; + char* locale; +}label_s; + +typedef struct _provider_feature_s +{ + char* key; + char* app_id; +}provider_feature_s; + +typedef struct _account_subscribe_s +{ + account_event_cb account_subscription_callback; + void* user_data; +}account_subscribe_s; + +/** + * @brief Enumarations for account handle fields. + */ + +typedef enum { + ACCOUNT_FIELD_NONE = -1, + ACCOUNT_FIELD_ID, + ACCOUNT_FIELD_USER_NAME, + ACCOUNT_FIELD_EMAIL_ADDRESS, + ACCOUNT_FIELD_DISPLAY_NAME, + ACCOUNT_FIELD_ICON_PATH, + ACCOUNT_FIELD_SOURCE, + ACCOUNT_FIELD_PACKAGE_NAME, + ACCOUNT_FIELD_ACCESS_TOKEN, + ACCOUNT_FIELD_DOMAIN_NAME, + ACCOUNT_FIELD_AUTH_TYPE, + ACCOUNT_FIELD_SECRET, + ACCOUNT_FIELD_SYNC_SUPPORT, + ACCOUNT_FIELD_USER_TEXT_0, + ACCOUNT_FIELD_USER_TEXT_1, + ACCOUNT_FIELD_USER_TEXT_2, + ACCOUNT_FIELD_USER_TEXT_3, + ACCOUNT_FIELD_USER_TEXT_4, + ACCOUNT_FIELD_USER_INT_0, + ACCOUNT_FIELD_USER_INT_1, + ACCOUNT_FIELD_USER_INT_2, + ACCOUNT_FIELD_USER_INT_3, + ACCOUNT_FIELD_USER_INT_4, + ACCOUNT_DB_FIELD_END, +} ACCOUNT_DB_IDX; + +/** + * @brief Enumarations for capability fields. + */ + +typedef enum { + CAPABILITY_FIELD_NONE = -1, + CAPABILITY_FIELD_ID, + CAPABILITY_FIELD_KEY, + CAPABILITY_FIELD_VALUE, + CAPABILITY_FIELD_PACKAGE_NAME, + CAPABILITY_FIELD_USER_NAME, + CAPABILITY_FIELD_ACCOUNT_ID, + CAPABILITY_FIELD_END, +}CAPABILITY_DB_IDX; + + +typedef enum { + ACCOUNT_CUSTOM_FIELD_NONE = -1, + ACCOUNT_CUSTOM_FIELD_ACCOUNT_ID, + ACCOUNT_CUSTOM_FIELD_APP_ID, + ACCOUNT_CUSTOM_FIELD_KEY, + ACCOUNT_CUSTOM_FIELD_VALUE, + ACCOUNT_CUSTOM_FIELD_END, +}ACCOUNT_CUSTOM_DB_IDX; + +typedef enum { + ACCOUNT_TYPE_FIELD_NONE = -1, + ACCOUNT_TYPE_FIELD_ID, + ACCOUNT_TYPE_FIELD_APP_ID, + ACCOUNT_TYPE_FIELD_SERVICE_PROVIDER_ID, + ACCOUNT_TYPE_FIELD_ICON_PATH, + ACCOUNT_TYPE_FIELD_SMALL_ICON_PATH, + ACCOUNT_TYPE_FIELD_MULTIPLE_ACCOUNT_SUPPORT, + ACCOUNT_TYPE_FIELD_END, +}ACCOUNT_TYPE_DB_IDX; + +typedef enum { + LABEL_FIELD_NONE = -1, + LABEL_FIELD_APP_ID, + LABEL_FIELD_LABEL, + LABEL_FIELD_LOCALE, + LABEL_FIELD_END, +}LABEL_DB_IDX; + +typedef enum { + PROVIDER_FEATURE_FIELD_NONE = -1, + PROVIDER_FEATURE_FIELD_APP_ID, + PROVIDER_FEATURE_FIELD_KEY, + PROVIDER_FEATURE_FIELD_END, +}PROVIDER_FEATURE_DB_IDX; + +typedef sqlite3_stmt* account_stmt; + +//ACCOUNT_TABLE +#define ACCOUNT_SCHEMA "create table account \n"\ + "(\n"\ +"_id INTEGER PRIMARY KEY AUTOINCREMENT, "\ +"user_name TEXT, "\ +"email_address TEXT, "\ +"display_name TEXT, "\ +"icon_path TEXT, "\ +"source TEXT, "\ +"package_name TEXT, "\ +"access_token TEXT, "\ +"domain_name TEXT, "\ +"auth_type INTEGER, "\ +"secret INTEGER, "\ +"sync_support INTEGER, "\ +"txt_custom0 TEXT, "\ +"txt_custom1 TEXT, "\ +"txt_custom2 TEXT, "\ +"txt_custom3 TEXT, "\ +"txt_custom4 TEXT, "\ +"int_custom0 INTEGER, "\ +"int_custom1 INTEGER, "\ +"int_custom2 INTEGER, "\ +"int_custom3 INTEGER, "\ +"int_custom4 INTEGER "\ +");" + +//CAPABILITY_TABLE +#define CAPABILITY_SCHEMA "create table capability \n"\ + "(\n"\ +"_id INTEGER PRIMARY KEY AUTOINCREMENT, "\ +"key TEXT, "\ +"value INTEGER, "\ +"package_name TEXT, "\ +"user_name TEXT, "\ +"account_id INTEGER "\ +");" + +//ACCOUNT_CUSTOM_TABLE +#define ACCOUNT_CUSTOM_SCHEMA "create table account_custom \n"\ + "(\n"\ +"AccountId INTEGER, "\ +"AppId TEXT, "\ +"Key TEXT, "\ +"Value TEXT "\ +");" + +//ACCOUNT_TYPE_TABLE +#define ACCOUNT_TYPE_SCHEMA "create table account_type \n"\ + "(\n"\ +"_id INTEGER PRIMARY KEY AUTOINCREMENT, "\ +"AppId TEXT, "\ +"ServiceProviderId TEXT, "\ +"IconPath TEXT, "\ +"SmallIconPath TEXT, "\ +"MultipleAccountSupport INTEGER "\ +");" + +//LABEL_TABLE +#define LABEL_SCHEMA "create table label \n"\ + "(\n"\ +"AppId TEXT, "\ +"Label TEXT, "\ +"Locale TEXT"\ +");" + +//PROVIDER_FEATURE_TABLE +#define PROVIDER_FEATURE_SCHEMA "create table provider_feature \n"\ + "(\n"\ +"app_id TEXT, "\ +"key TEXT "\ +");" + +typedef struct GSList account_iterator_s; + +#ifdef __cplusplus +} +#endif + +#endif /* __SLP_ACCOUNT_PRIVATE_TYPES_H__*/ diff --git a/include/account-types.h b/include/account-types.h new file mode 100755 index 0000000..5eb582f --- /dev/null +++ b/include/account-types.h @@ -0,0 +1,261 @@ +/* + * + * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Wonyoung Lee <wy1115.lee@samsung.com>, Sungchan Kim <sungchan81.kim@samsung.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef __ACCOUNT_TYPES_H__ +#define __ACCOUNT_TYPES_H__ + +#ifdef __cplusplus +extern "C" +{ +#endif + + +/** + * @addtogroup CAPI_ACCOUNT_MANAGER_MODULE + * @{ + */ + +/** + * @file account-types.h + * @ingroup CAPI_ACCOUNT + * @brief This file defines common types and enums of ACCOUNT. + */ + +/** + * @brief Enumeration for the state of capability. + * @since_tizen 2.3 + */ +typedef enum +{ + ACCOUNT_CAPABILITY_STATE_INVALID = 0, /**< Account capability is invalid */ + ACCOUNT_CAPABILITY_DISABLED, /**< Account capability is disabled */ + ACCOUNT_CAPABILITY_ENABLED, /**< Account capability is enabled */ + ACCOUNT_CAPABILITY_STATE_MAX +} +account_capability_state_e; + +/** + * @brief Enumeration for the state of account secrecy. + * @since_tizen 2.3 + */ +typedef enum +{ + ACCOUNT_SECRECY_INVALID = 0, /**< Account secrecy is invalid */ + ACCOUNT_SECRECY_INVISIBLE, /**< Account is not visible */ + ACCOUNT_SECRECY_VISIBLE, /**< Account is visible */ + ACCOUNT_SECRECY_MAX +} +account_secrecy_state_e; + +/** + * @brief Enumeration for the account sync status. + * @since_tizen 2.3 + */ +typedef enum +{ + ACCOUNT_SYNC_INVALID = 0, /**< Account sync is invalid */ + ACCOUNT_SYNC_NOT_SUPPORT, /**< Account sync not supported */ + ACCOUNT_SYNC_STATUS_OFF, /**< Account sync supported but all synchronization functionalities are off */ + ACCOUNT_SYNC_STATUS_IDLE, /**< Account sync support and sync status is idle */ + ACCOUNT_SYNC_STATUS_RUNNING, /**< Account sync support and sync status is running */ + ACCOUNT_SUPPORTS_SYNC, /**< NOT USED, WILL BE REMOVED TO PREVENT BUILD ERROR */ + ACCOUNT_NOT_SUPPORTS_SYNC, /**< NOT USED, WILL BE REMOVED TO PREVENT BUILD ERROR */ + ACCOUNT_SYNC_MAX +} +account_sync_state_e; + +/** + * @brief Enumeration for the account auth type. + * @since_tizen 2.3 + */ +typedef enum +{ + ACCOUNT_AUTH_TYPE_INVALID = 0, /**< Auth type is invalid */ + ACCOUNT_AUTH_TYPE_XAUTH, /**< XAuth type */ + ACCOUNT_AUTH_TYPE_OAUTH, /**< OAuth type */ + ACCOUNT_AUTH_TYPE_CLIENT_LOGIN, /**< Client-Login type */ + ACCOUNT_AUTH_TYPE_MAX +}account_auth_type_e; + +/** + * @brief The structure type for the Account handle. + * @since_tizen 2.3 + */ +typedef struct account_s* account_h; + +/** + * @brief The structure type for the Account provider handle. + * @since_tizen 2.3 + */ +typedef struct account_type_s* account_type_h; + +/** + * @brief The structure type for the Account handle. + * @since_tizen 2.3 + */ +typedef struct label_s* label_h; + + +/** + * @brief The structure type for the Account subscribe handle. + * @since_tizen 2.3 + */ +typedef struct account_subscribe_s* account_subscribe_h; + +/** + * @brief The insert notification type. + * @since_tizen 2.3 + * @remarks When the account database is changed, You can distinguish one event type from the other which are set for subscribing notification. + * + * @see account_subscribe_notification() + */ +#define ACCOUNT_NOTI_NAME_INSERT "insert" + +/** + * @brief The update notification type. + * @since_tizen 2.3 + * @remarks When the account database is changed, You can distinguish one event type from the other which are set for subscribing notification. + * + * @see account_subscribe_notification() + */ +#define ACCOUNT_NOTI_NAME_UPDATE "update" + +/** + * @brief The delete notification type. + * @since_tizen 2.3 + * @remarks When the account database is changed, You can distinguish one event type from the other which are set for subscribing notification. + * + * @see account_subscribe_notification() + */ +#define ACCOUNT_NOTI_NAME_DELETE "delete" + +/** + * @brief The sync_update notification type. + * @since_tizen 2.3 + * @remarks When the account database is changed, You can distinguish one event type from the other which are set for subscribing notification. + * + * @see account_subscribe_notification() + */ +#define ACCOUNT_NOTI_NAME_SYNC_UPDATE "sync_update" + + +/** + * @brief This is a key of app_control_h’s extra data. The value of the key is a user account name. + * @since_tizen 2.3 + * @remarks You can retrieve the value like this, app_control_get_extra_data(app_control, ACCOUNT_DATA_USERNAME, &username).\n + This value will be sent with ACCOUNT_OPERATION_VIEW. + */ +#define ACCOUNT_DATA_USERNAME "http://tizen.org/account/data/username" + +/** + * @brief This is a key of app_control_h’s extra data. The value of the key is account DB ID of the user’s account information. + * @since_tizen 2.3 + * @remarks You can retrieve the value like this, app_control_get_extra_data(app_control, ACCOUNT_DATA_ID, &id).\n + This value will be sent with ACCOUNT_OPERATION_VIEW. + */ +#define ACCOUNT_DATA_ID "http://tizen.org/appcontrol/data/account/id" + +/** + * @brief This is an application launch operation name. + * @since_tizen 2.3 + * @remarks This operation will be sent when a user selects your account in add account view. + */ +#define ACCOUNT_OPERATION_SIGNIN "http://tizen.org/appcontrol/operation/account/add" + +/** + * @brief This is an application launch operation name. + * @since_tizen 2.3 + * @remarks This operation will be sent when a user selects your account in account list view. + */ +#define ACCOUNT_OPERATION_VIEW "http://tizen.org/appcontrol/operation/account/configure" + +/** + * @brief This is contact capability string. + * @since_tizen 2.3 + * @remarks If your provider service has contact information and contact information is provided another application, register this capability through manifest file. + */ +#define ACCOUNT_SUPPORTS_CAPABILITY_CONTACT "http://tizen.org/account/capability/contact" + +/** + * @brief This is calendar capability string. + * @since_tizen 2.3 + * @remarks If your provider service has calendar information and calendar information is provided another application, register this capability through manifest file. + */ +#define ACCOUNT_SUPPORTS_CAPABILITY_CALENDAR "http://tizen.org/account/capability/calendar" + +/** + * @brief This is email capability string. + * @since_tizen 2.3 + * @remarks If your provider service have email service and email is provided another application, register this capability through manifest file. + */ +#define ACCOUNT_SUPPORTS_CAPABILITY_EMAIL "http://tizen.org/account/capability/email" + +/** + * @brief This is photo capability string. + * @since_tizen 2.3 + * @remarks If your provider service has photo and photo is provided another application, register this capability through manifest file. + */ +#define ACCOUNT_SUPPORTS_CAPABILITY_PHOTO "http://tizen.org/account/capability/photo" + +/** + * @brief This is video capability string. + * @since_tizen 2.3 + * @remarks If your provider service has video and video is provided another application, register this capability through manifest file. + */ +#define ACCOUNT_SUPPORTS_CAPABILITY_VIDEO "http://tizen.org/account/capability/video" + +/** + * @brief This is music capability string. + * @since_tizen 2.3 + * @remarks If your provider service has music and music is provided another application, register this capability through manifest file. + */ +#define ACCOUNT_SUPPORTS_CAPABILITY_MUSIC "http://tizen.org/account/capability/music" + +/** + * @brief This is document capability string. + * @since_tizen 2.3 + * @remarks If your provider service has document and document is provided another application, register this capability through manifest file. + */ +#define ACCOUNT_SUPPORTS_CAPABILITY_DOCUMENT "http://tizen.org/account/capability/document" + +/** + * @brief This is message capability string. + * @since_tizen 2.3 + * @remarks This capability will be exploited to use SMS, MMS. + */ +#define ACCOUNT_SUPPORTS_CAPABILITY_MESSAGE "http://tizen.org/account/capability/message" + +/** + * @brief This is game capability string. + * @since_tizen 2.3 + * @remarks This capability will be exploited to use game data. + */ +#define ACCOUNT_SUPPORTS_CAPABILITY_GAME "http://tizen.org/account/capability/game" + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* __ACCOUNT_TYPES_H__*/ + diff --git a/include/account.h b/include/account.h new file mode 100755 index 0000000..fefd4fe --- /dev/null +++ b/include/account.h @@ -0,0 +1,2036 @@ +/* + * + * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Wonyoung Lee <wy1115.lee@samsung.com>, Sungchan Kim <sungchan81.kim@samsung.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef __ACCOUNT_H__ +#define __ACCOUNT_H__ + +#include <account-types.h> +#include <account-error.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + +#ifndef ACCOUNT_API +#define ACCOUNT_API __attribute__ ((visibility("default"))) +#endif + +/** + * @file account.h + * @brief This file contains the Account API for account management. + */ + +/** + * @addtogroup CAPI_ACCOUNT_MANAGER_MODULE + * @{ + */ + +/** + * @brief Called once for each account from the database. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] user_data The user data passed from the foreach function + * + * @return @c true to continue with the next iteration of the loop, \n + * otherwise @c false to break out of the loop + * + * @pre account_foreach_account_from_db(), account_query_account_by_account_id(), account_query_account_by_user_name() or account_query_account_by_package_name() must be called. + * + * @see account_foreach_account_from_db() + * @see account_query_account_by_account_id() + * @see account_query_account_by_user_name() + * @see account_query_account_by_package_name() + */ +typedef bool (*account_cb)(account_h account, void *user_data); + +/** + * @brief Called once for each capability of an account in the database. + * + * @since_tizen 2.3 + * @param[in] capability_type The capability type + * @param[in] capability_state The capability state + * @param[in] user_data The user data passed from the foreach function + * + * @return @c true to continue with the next iteration of the loop, \n + * otherwise @c false to break out of the loop + * + * @pre account_query_capability_by_account_id() must be called. + * + * @see account_query_capability_by_account_id() + */ +typedef bool (*capability_cb)(const char* capability_type, account_capability_state_e capability_state, void *user_data); + +/** + * @brief Called once for each custom data of an account in the database. + * + * @since_tizen 2.3 + * @param[in] key The user custom key + * @param[in] value The user custom value of the specific key + * @param[in] user_data The user data passed + * + * @return @c true to continue with the next iteration of the loop, \n + * otherwise @c false to break out of the loop + * + * @pre account_query_capability_by_account_id() must be called. + * + * @see account_query_capability_by_account_id() + */ +typedef bool (*account_custom_cb)(char* key, char* value, void *user_data); + + +/** + * @brief Called once for each account provider in the database. + * + * @since_tizen 2.3 + * @param[in] account_type The account provider handle + * @param[in] user_data The user data passed + * + * @return @c true to continue with the next iteration of the loop, \n + * otherwise @c false to break out of the loop + * + * @pre account_type_foreach_account_type_from_db(), account_type_query_by_provider_feature() must be called. + * + * @see account_type_foreach_account_type_from_db() + * @see account_type_query_by_provider_feature() + */ +typedef bool (*account_type_cb)(account_type_h account_type, void *user_data); + + +/** + * @brief Called once for each account label. + * + * @since_tizen 2.3 + * @param[in] app_id The application ID + * @param[in] label The name of the account depends on the specified locale + * @param[in] locale The locale is specified as an ISO 3166 alpha-2 two letter country-code followed by ISO 639-1 for the two-letter language code.\n + * For example, "ko_KR" for Korean, "en_US" for American English. + * @param[in] user_data The user data passed + * + * @return @c true to continue with the next iteration of the loop, \n + * otherwise @c false to break out of the loop + * + * @pre account_type_get_label(), account_type_query_label_by_app_id() must be called. + * + * @see account_type_get_label() + * @see account_type_query_label_by_app_id() + */ +typedef bool (*account_label_cb)(char* app_id, char* label, char* locale, void *user_data); + + +/** + * @brief Called once for each capability of an account provider in the database. + * + * @since_tizen 2.3 + * @param[in] app_id The application ID + * @param[in] key The user custom key + * @param[in] user_data The user data passed + * + * @return @c true to continue with the next iteration of the loop, \n + * otherwise @c false to break out of the loop + * + * @pre account_type_query_provider_feature_by_app_id(), account_type_get_provider_feature_all() must be called. + * + * @see account_type_query_provider_feature_by_app_id() + * @see account_type_get_provider_feature_all() + */ +typedef bool (*provider_feature_cb)(char* app_id, char* key, void* user_data); + + +/** + * @brief Called once when an event occurs. + * + * @since_tizen 2.3 + * @param[in] event_type The account event type + * @param[in] account_id The account ID to update + * @param[in] user_data The user data passed + * + * @return @c true to continue with the next iteration of the loop, \n + * otherwise @c false to break out of the loop + * + * @pre account_subscribe_notification() must be called. + * + * @see account_subscribe_notification() + */ +typedef bool (*account_event_cb)(const char* event_type, int account_id, void* user_data); + + +/** + * @brief Connects to the account database by readwrite mode. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_DB_NOT_OPENED DB is not connected + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @see account_disconnect() + */ +ACCOUNT_API int account_connect(void); + + +/** + * @brief Connects to the account database by readonly mode. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_DB_NOT_OPENED DB is not connected + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @see account_disconnect() + */ +ACCOUNT_API int account_connect_readonly(void); + + +/** + * @brief Disconnects from the account database. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * @retval #ACCOUNT_ERROR_DATABASE_BUSY SQLite busy handler expired + * + * @see account_connect() + */ +ACCOUNT_API int account_disconnect(void); + + +/** + * @brief Creates a handle to the account. + * + * @since_tizen 2.3 + * @remarks Release @a account using account_destroy(). + * @remarks The created handle is not added to the account database until account_insert_to_db() is called. + * + * @param[in] account The account handle + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of Memory + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_destroy() + */ +ACCOUNT_API int account_create(account_h *account); + + +/** + * @brief Destroys the account handle and releases all its resources. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_create() + */ +ACCOUNT_API int account_destroy(account_h account); + + +/** + * @brief Inserts the account details to the account database. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @param[in] account The account handle + * @param[out] account_db_id The account ID to be assigned to an account + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_DUPLICATED Same user name exists in your application + * @retval #ACCOUNT_ERROR_NOT_ALLOW_MULTIPLE Tried to add an account in spite of multiple false accounts + * @retval #ACCOUNT_ERROR_NOT_REGISTERED_PROVIDER Tried to add an account though you did not register the account provider in manifest + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_delete_from_db_by_id() + * @see account_delete_from_db_by_user_name() + * @see account_delete_from_db_by_package_name() + * @see account_update_to_db_by_id() + * @see account_update_to_db_by_user_name() + */ +ACCOUNT_API int account_insert_to_db(account_h account, int *account_db_id); + + +/** + * @brief Deletes an account from the account database by account DB ID. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @param[in] account_db_id The account ID to delete + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED The account owner is different from the caller or DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_insert_to_db() + * @see account_delete_from_db_by_user_name() + * @see account_delete_from_db_by_package_name() + * @see account_update_to_db_by_id() + * @see account_update_to_db_by_user_name() + */ +ACCOUNT_API int account_delete_from_db_by_id(int account_db_id); + + +/** + * @brief Deletes an account from the account database by user name. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @param[in] user_name The user name of the account to delete + * @param[in] package_name The package name of the account to delete + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_insert_to_db() + * @see account_delete_from_db_by_id() + * @see account_delete_from_db_by_package_name() + * @see account_update_to_db_by_id() + * @see account_update_to_db_by_user_name() + */ +ACCOUNT_API int account_delete_from_db_by_user_name(char *user_name, char *package_name); + + +/** + * @brief Deletes an account from the account database by package name. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @param[in] package_name The package name of account(s) to delete + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_insert_to_db() + * @see account_delete_from_db_by_id() + * @see account_delete_from_db_by_user_name() + * @see account_update_to_db_by_id() + * @see account_update_to_db_by_user_name() + */ +ACCOUNT_API int account_delete_from_db_by_package_name(const char *package_name); + + +/** + * @brief Updates the account details to the account database. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @param[in] account The account handle + * @param[in] account_id The account ID to update + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_RECORD_NOT_FOUND The account to update does not exist + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_insert_to_db() + * @see account_delete_from_db_by_id() + * @see account_delete_from_db_by_user_name() + * @see account_delete_from_db_by_package_name() + * @see account_update_to_db_by_user_name() + */ +ACCOUNT_API int account_update_to_db_by_id(account_h account, int account_id); + + +/** + * @brief Updates the account details to the account database without checking provider's permission. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @param[in] account The account handle + * @param[in] account_id The account ID to update + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_RECORD_NOT_FOUND The account to update does not exist + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_insert_to_db() + * @see account_delete_from_db_by_id() + * @see account_delete_from_db_by_user_name() + * @see account_delete_from_db_by_package_name() + * @see account_update_to_db_by_user_name() + */ +ACCOUNT_API int account_update_to_db_by_id_ex(account_h account, int account_id); + +/** + * @brief Updates the account details to the account database. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @param[in] account The account handle + * @param[in] user_name The user name of the account to update + * @param[in] package_name The package name for the user name + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_RECORD_NOT_FOUND The account to update does not exist + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_insert_to_db() + * @see account_delete_from_db_by_id() + * @see account_delete_from_db_by_user_name() + * @see account_delete_from_db_by_package_name() + * @see account_update_to_db_by_id() + * + */ +ACCOUNT_API int account_update_to_db_by_user_name(account_h account, const char *user_name, const char *package_name); + +/** + * @brief Gets the ID of an account. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[out] account_id The account ID + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + */ +ACCOUNT_API int account_get_account_id(account_h account, int *account_id); + +/** + * @brief Gets the user name of an account. + * + * @since_tizen 2.3 + * @remarks You must release @a user_name using free(). + * + * @param[in] account The account handle + * @param[out] user_name The user name of the account + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_set_user_name() + */ +ACCOUNT_API int account_get_user_name(account_h account, char **user_name); + + +/** + * @brief Sets the user name of an account. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] user_name The string to set as user name + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_user_name() + */ +ACCOUNT_API int account_set_user_name(account_h account, const char *user_name); + + +/** + * @brief Gets the display name of an account. + * + * @since_tizen 2.3 + * @remarks You must release @a display_name using free(). + * + * @param[in] account The account handle + * @param[out] display_name The display name of the account + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_get_display_name() + */ +ACCOUNT_API int account_get_display_name(account_h account, char **display_name); + + +/** + * @brief Sets the display name of an account. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] display_name The text string to set as the display name + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_display_name() + */ +ACCOUNT_API int account_set_display_name(account_h account, const char *display_name); + +/** + * @brief Gets the capability detail of an account. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] capability_type The capability type to get the capability value + * @param[out] capability_value The capability value (on/off) of the specified capability_type + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_RECORD_NOT_FOUND There is no given capability_type in the account + * + * @see account_set_capability() + */ +ACCOUNT_API int account_get_capability(account_h account, const char* capability_type, account_capability_state_e* capability_value); + +/** + * @brief Gets all the capabilities of an account. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] callback The callback function + * @param[in] user_data The user data to be passed to the callback function + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_set_capability() + */ +ACCOUNT_API int account_get_capability_all(account_h account, capability_cb callback, void *user_data); + +/** + * @brief Sets the capability. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] capability_type The capability type + * @param[in] capability_state The capability state + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_capability() + */ +ACCOUNT_API int account_set_capability(account_h account, const char* capability_type, account_capability_state_e capability_state); + + +/** + * @brief Gets the icon path. + * + * @since_tizen 2.3 + * @remarks You must release @a icon_path using free(). + * + * @param[in] account The account handle + * @param[out] icon_path The icon path + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_set_icon_path() + */ +ACCOUNT_API int account_get_icon_path(account_h account, char **icon_path); + + +/** + * @brief Sets the icon path. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] icon_path The text string to set as the icon path + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_icon_path() + */ +ACCOUNT_API int account_set_icon_path(account_h account, const char *icon_path); + + +/** + * @brief Gets the domain name. + * + * @since_tizen 2.3 + * @remarks You must release @a domain_name using free(). + * + * @param[in] account The account handle + * @param[out] domain_name The domain name + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_set_domain_name() + */ +ACCOUNT_API int account_get_domain_name(account_h account, char **domain_name); + + +/** + * @brief Sets the domain name. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] domain_name The text string to set as the domain name + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_domain_name() + */ +ACCOUNT_API int account_set_domain_name(account_h account, const char *domain_name); + + +/** + * @brief Gets the email address. + * + * @since_tizen 2.3 + * @remarks You must release @a email_address using free(). + * + * @param[in] account The account handle + * @param[out] email_address The email address + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_set_email_address() + */ +ACCOUNT_API int account_get_email_address(account_h account, char **email_address); + + +/** + * @brief Sets the email address. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] email_address The text string to set as the email address + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_email_address() + */ +ACCOUNT_API int account_set_email_address(account_h account, const char *email_address); + + +/** + * @brief Gets the package name. + * + * @since_tizen 2.3 + * @remarks You must release @a package_name using free(). + * + * @param[in] account The account handle + * @param[out] package_name The package name + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_set_package_name() + */ +ACCOUNT_API int account_get_package_name(account_h account, char **package_name); + + +/** + * @brief Sets the package name. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] package_name The text string to set as the package name + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_email_address() + */ +ACCOUNT_API int account_set_package_name(account_h account, const char *package_name); + + +/** + * @brief Gets the access token. + * + * @since_tizen 2.3 + * @remarks You must release @a access_token using free(). + * + * @param[in] account The account handle + * @param[out] access_token The access token + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_set_access_token() + */ +ACCOUNT_API int account_get_access_token(account_h account, char **access_token); + + +/** + * @brief Sets the access token. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] access_token The text string to set as the access token + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_access_token() + */ +ACCOUNT_API int account_set_access_token(account_h account, const char *access_token); + + +/** + * @brief Gets the user text. + * + * @since_tizen 2.3 + * @remarks You must release @a user_text using free(). + * + * @param[in] account The account handle + * @param[in] user_text_index The index of the user text (range: 0 ~ 4) + * @param[out] user_text The user text + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_set_user_text() + */ +ACCOUNT_API int account_get_user_text(account_h account, int user_text_index, char **user_text); + + +/** + * @brief Sets the user text. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] user_text_index The index of the user text (must be in range from @c 0 to @c 4) + * @param[in] user_text The text string to set as the user text + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_user_text() + */ +ACCOUNT_API int account_set_user_text(account_h account, int user_text_index, const char *user_text); + + +/** + * @brief Gets the user integer. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] user_int_index The index of the user integer (must be in range from @c 0 to @c 4) + * @param[out] user_integer The user integer + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_set_user_int() + */ +ACCOUNT_API int account_get_user_int(account_h account, int user_int_index, int *user_integer); + + +/** + * @brief Sets the user integer. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] user_int_index The index of the user integer (must be in range from @c 0 to @c 4) + * @param[in] user_integer The integer to set as the user integer + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_user_int() + */ +ACCOUNT_API int account_set_user_int(account_h account, int user_int_index, int user_integer); + + +/** + * @brief Gets the auth type. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[out] auth_type The auth type + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_set_auth_type() + */ +ACCOUNT_API int account_get_auth_type(account_h account, account_auth_type_e *auth_type); + + +/** + * @brief Sets the auth type. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] auth_type The integer to be set as the auth type + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_auth_type() + */ +ACCOUNT_API int account_set_auth_type(account_h account, const account_auth_type_e auth_type); + + +/** + * @brief Gets the secret. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[out] secret The secret + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_set_secret() + */ +ACCOUNT_API int account_get_secret(account_h account, account_secrecy_state_e *secret); + + +/** + * @brief Sets the secret. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] secret The secrecy to be set + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_secret() + */ +ACCOUNT_API int account_set_secret(account_h account, const account_secrecy_state_e secret); + +/** + * @brief Gets the sync support. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[out] sync_support The sync support + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_set_sync_support() + */ +ACCOUNT_API int account_get_sync_support(account_h account, account_sync_state_e *sync_support); + + +/** + * @brief Sets the sync support. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] sync_support The sync state to be set + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_sync_support() + */ +ACCOUNT_API int account_set_sync_support(account_h account, const account_sync_state_e sync_support); + + +/** + * @brief Gets the source. + * + * @since_tizen 2.3 + * @remarks You must release @a user_text using free(). + * + * @param[in] account The account handle + * @param[out] source The source + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_set_source() + */ +ACCOUNT_API int account_get_source(account_h account, char **source); + + +/** + * @brief Sets the source. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] source The text string to set as the source + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_source() + */ +ACCOUNT_API int account_set_source(account_h account, const char *source); + +/** + * @brief Sets the custom. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] key The user custom key for the specific value + * @param[in] value The user custom value about the given key + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_get_custom() + */ +ACCOUNT_API int account_set_custom(account_h account, const char* key, const char* value); + +/** + * @brief Gets the user specific custom text of an account key. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] key The key to retrieve custom text + * @param[out] value The text of the given key + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_RECORD_NOT_FOUND There is no given capability type in the account + * + * @see account_set_custom() + */ +ACCOUNT_API int account_get_custom(account_h account, const char* key, char** value); + + +/** + * @brief Gets all the user custom texts of an account. + * + * @since_tizen 2.3 + * @param[in] account The account handle + * @param[in] callback The callback function to retrieve all custom text \n + * The callback function gives the key and value. + * @param[in] user_data The user data to be passed to the callback function + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_set_custom() + */ +ACCOUNT_API int account_get_custom_all(account_h account, account_custom_cb callback, void* user_data); + +/** + * @brief Retrieves all accounts details by invoking the given callback function iteratively. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] callback The callback function to invoke + * @param[in] user_data The user data to be passed to the callback function + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * @retval #ACCOUNT_ERROR_RECORD_NOT_FOUND Related record does not exist + * + * @pre This function requires an open connection to an account service by account_connect(). + * @post This function invokes account_cb(). + * + * @see account_connect() + * @see account_query_account_by_account_id() + * @see account_query_account_by_user_name() + * @see account_query_account_by_package_name() + * @see account_query_account_by_capability() + */ +ACCOUNT_API int account_foreach_account_from_db(account_cb callback, void *user_data); + + +/** + * @brief Retrieve an account with the account ID. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] account_db_id The account database ID to search + * @param[out] account The account handle \n + * Must be allocated by account_create() and freed after using by account_destroy(). + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_query_account_by_user_name() + * @see account_query_account_by_package_name() + * @see account_query_account_by_capability() + */ +ACCOUNT_API int account_query_account_by_account_id(int account_db_id, account_h *account); + +/** + * @brief Retrieves all accounts with the user name. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] callback The callback function to invoke + * @param[in] user_name The user name to search + * @param[in] user_data The user data to be passed to the callback function + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * @post This function invokes account_cb(). + * + * @see account_connect() + * @see account_foreach_account_from_db() + * @see account_query_account_by_account_id() + * @see account_query_account_by_package_name() + * @see account_query_account_by_capability() + * + */ +ACCOUNT_API int account_query_account_by_user_name(account_cb callback, const char* user_name, void* user_data); + +/** + * @brief Retrieves all accounts with the package name. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] callback The callback function to invoke + * @param[in] package_name The package name to search + * @param[in] user_data The user data to be passed to the callback function + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * @post This function invokes account_cb(). + * + * @see account_connect() + * @see account_foreach_account_from_db() + * @see account_query_account_by_account_id() + * @see account_query_account_by_user_name() + * @see account_query_account_by_capability() + */ +ACCOUNT_API int account_query_account_by_package_name(account_cb callback, const char *package_name, void *user_data); + +/** + * @brief Retrieves all accounts with the capability type and capability value. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] callback The callback function to invoke + * @param[in] capability_type The capability type to search + * @param[in] capability_value The capability value to search + * @param[in] user_data The user data to be passed to the callback function + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * @post This function invokes account_cb(). + * + * @see account_connect() + * @see account_foreach_account_from_db() + * @see account_query_account_by_account_id() + * @see account_query_account_by_user_name() + * @see account_query_account_by_package_name() + */ +ACCOUNT_API int account_query_account_by_capability(account_cb callback, const char* capability_type, account_capability_state_e capability_value, void *user_data); + +/** + * @brief Retrieves all accounts with the capability type. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] callback The callback function to invoke + * @param[in] capability_type The capability type to search + * @param[in] user_data The user data to be passed to the callback function + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * @post This function invokes account_cb(). + * + * @see account_connect() + * @see account_foreach_account_from_db() + * @see account_query_account_by_account_id() + * @see account_query_account_by_user_name() + * @see account_query_account_by_package_name() + */ +ACCOUNT_API int account_query_account_by_capability_type(account_cb callback, const char* capability_type, void* user_data); + +/** + * @brief Retrieves all capabilities with the account database ID. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] callback The callback function to invoke + * @param[in] account_db_id The account database ID to search + * @param[in] user_data The user data to be passed to the callback function + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * @post This function invokes capability_cb(). + * + * @see account_connect() + * @see account_get_capability() + * @see account_set_capability() + */ +ACCOUNT_API int account_query_capability_by_account_id(capability_cb callback, int account_db_id, void *user_data); + + +/** + * @brief Gets the count of accounts in the account database. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[out] count The out parameter for count of all accounts + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + */ +ACCOUNT_API int account_get_total_count_from_db(int *count); + +/** + * @brief Updates the sync status of an account with the given account ID. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @param[in] account_db_id The account ID for which sync status needs to be changed + * @param[in] sync_status The new sync status + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + */ +ACCOUNT_API int account_update_sync_status_by_id(int account_db_id, const account_sync_state_e sync_status); + + +/* Account type API */ + + +/** + * @brief Creates a handle to the account provider. + * + * @since_tizen 2.3 + * @remarks You must release @a account_type handle using account_type_destroy().\n + * + * @param[in] account_type The account provider handle + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of Memory + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_type_destroy() + */ +ACCOUNT_API int account_type_create(account_type_h *account_type); + +/** + * @brief Destroys the account provider handle and releases all its resources. + * + * @since_tizen 2.3 + * + * @remarks When you get @a account_type_h using account_type_create(), you must release the handle using account_destroy() to avoid the memory leak. + * + * @param[in] account_type The account provider handle + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_type_create() + */ +ACCOUNT_API int account_type_destroy(account_type_h account_type); + +/** + * @internal + * @brief Sets the app ID. + * It should be filled with your application ID. For example, com.tizen.testapp. + * + * @since_tizen 2.3 + * @remarks @a app_id is a mandatory field and does not allow duplicate app ID in the account provider database. + * + * @param[in] account_type The account provider handle \n + * It should be assigned by account_type_create(). + * @param[in] app_id The application ID + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_type_get_app_id() + */ +ACCOUNT_API int account_type_set_app_id(account_type_h account_type, const char *app_id); + +/** + * @internal + * @brief Sets the service provider ID. + * It should be filled with your service provider ID. + * + * @since_tizen 2.3 + * @remarks @a service_provider_id is a mandatory field. + * + * @param[in] account_type The account provider handle \n + * It should be assigned by account_type_create(). + * @param[in] service_provider_id The service provider ID + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_type_get_service_provider_id() + */ +ACCOUNT_API int account_type_set_service_provider_id(account_type_h account_type, const char *service_provider_id); + +/** + * @internal + * @brief Sets icon path. + * It represents your service provider or an application. + * + * @since_tizen 2.3 + * @remarks @a icon_path is not a mandatory field. But when it is set, you can display this icon in the Add Account screen. + * + * @param[in] account_type The account provider handle\n + * It should be assigned by account_type_create(). + * @param[in] icon_path The icon path of the application + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_type_get_icon_path() + */ +ACCOUNT_API int account_type_set_icon_path(account_type_h account_type, const char *icon_path); + +/** + * @internal + * @brief Sets small icon path. + * It also represents your service provider or an application. + * + * @since_tizen 2.3 + * @remarks @a small_icon_path is not a mandatory field. + * + * @param[in] account_type The account provider handle \n + * It should be assigned by account_type_create(). + * @param[in] small_icon_path The scaled icon of your application + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_type_get_small_icon_path() + */ +ACCOUNT_API int account_type_set_small_icon_path(account_type_h account_type, const char *small_icon_path); + +/** + * @internal + * @brief Sets support for multiple accounts. + * It represents whether your application supports multiple accounts. + * + * @since_tizen 2.3 + * @remarks The default value of multiple account support is @c FALSE. + * + * @param[in] account_type The account provider handle \n + * It should be assigned by account_type_create(). + * @param[in] multiple_account_support Set @c TRUE if your application can support two or more accounts, \n + * otherwise @c FALSE if your application can support only one account + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_type_get_multiple_account_support() + */ +ACCOUNT_API int account_type_set_multiple_account_support(account_type_h account_type, const bool multiple_account_support); + +/** + * @internal + * @brief Sets label and locale. + * Label represents the name of an account provider. + * + * @since_tizen 2.3 + * @param[in] account_type The account provider handle \n + * It should be assigned by account_type_create(). + * @param[in] label The name of account depends on the specified locale + * @param[in] locale The locale is specified as an ISO 3166 alpha-2 two letter country-code followed by ISO 639-1 for the two-letter language code.\n + * For example, "ko_KR" for Korean, "en_US" for American English. + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_type_get_label() + */ +ACCOUNT_API int account_type_set_label(account_type_h account_type, const char* label, const char* locale); + +/** + * @internal + * @brief Sets the capability. + * + * @since_tizen 2.3 + * @param[in] account_type The account provider handle + * @param[in] provider_feature Th capability key of the account + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_set_capability() + */ +ACCOUNT_API int account_type_set_provider_feature(account_type_h account_type, const char* provider_feature); + +/** + * @brief Retrieves capability information with your application ID. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] callback The callback function carries the capability name of an app ID + * @param[in] app_id The application ID to search + * @param[in] user_data The user data \n + * If you have your private data to carry into callback function, then you can use it. + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_disconnect() + */ +ACCOUNT_API int account_type_query_provider_feature_by_app_id(provider_feature_cb callback, const char* app_id, void *user_data ); + +/** + * @brief Checks whether the given application ID supports the capability. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @remarks The specific error code can be obtained using the get_last_result() method. Error codes are described in Exception section. + * @param[in] app_id The application ID + * @param[in] capability The capability \n + * For example, ACCOUNT_SUPPORTS_CAPABILITY_CONTACT or "http://tizen.org/account/capability/contact" + * + * @return @c TRUE if the application supports the given capability, \n + * otherwise @c FALSE if the application does not support the given capability + * @retval @c TRUE means the application supports the given capability + * @retval @c FALSE means the application does not support the given capability + * @exception #ACCOUNT_ERROR_NONE Successful + * @exception #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @exception #ACCOUNT_ERROR_RECORD_NOT_FOUND Related record does not exist + * @exception #ACCOUNT_ERROR_PERMISSION_DENIED DB access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_disconnect() + */ +ACCOUNT_API bool account_type_query_supported_feature(const char* app_id, const char* capability); + +/** + * @brief Gets the application ID of an account provider. + * + * @since_tizen 2.3 + * @remarks You must release @a app_id using free(). + * + * @param[in] account_type The account provider handle \n + * It should be given by account_type_query_* functions or account_type_foreach_account_type_from_db(). + * @param[out] app_id The application ID of an account provider item + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_type_foreach_account_type_from_db() + * @see account_type_query_by_app_id() + */ +ACCOUNT_API int account_type_get_app_id(account_type_h account_type, char **app_id); + +/** + * @brief Gets the service provider ID of an account provider. + * + * @since_tizen 2.3 + * @remarks You must release @a service_provider_id using free(). + * + * @param[in] account_type The account provider handle \n + * It should be given by account_type_query_* functions or account_type_foreach_account_type_from_db(). + * @param[out] service_provider_id The service provider text ID of an account provider item + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_type_foreach_account_type_from_db() + * @see account_type_query_by_app_id() + */ +ACCOUNT_API int account_type_get_service_provider_id(account_type_h account_type, char **service_provider_id); + +/** + * @brief Gets the icon path of an account provider. + * + * @since_tizen 2.3 + * @remarks You must release @a icon_path using free(). + * + * @param[in] account_type The account provider handle \n + * It should be given by account_type_query_* functions or account_type_foreach_account_type_from_db(). + * @param[out] icon_path The icon path of the account provider item + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_type_foreach_account_type_from_db() + * @see account_type_query_by_app_id() + */ +ACCOUNT_API int account_type_get_icon_path(account_type_h account_type, char **icon_path); + +/** + * @brief Gets the small icon path of an account provider. + * + * @since_tizen 2.3 + * @remarks You must release @a small_icon_path using free(). + * + * @param[in] account_type The account provider handle\n + * It should be given by account_type_query_* functions or account_type_foreach_account_type_from_db(). + * @param[out] small_icon_path The small icon path of the account provider item + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_type_foreach_account_type_from_db() + * @see account_type_query_by_app_id() + */ +ACCOUNT_API int account_type_get_small_icon_path(account_type_h account_type, char **small_icon_path); + +/** + * @brief Checks whether the given account provider supports multiple accounts. + * + * @since_tizen 2.3 + * @param[in] account_type The account provider handle \n + * It should be given by account_type_query_* functions or account_type_foreach_account_type_from_db. + * @param[out] multiple_account_support The flag indicating support for multiple accounts accounts\n + * TRUE or FALSE. + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of memory + * + * @see account_type_foreach_account_type_from_db() + * @see account_type_query_by_app_id() + */ +ACCOUNT_API int account_type_get_multiple_account_support(account_type_h account_type, int *multiple_account_support); + +/** + * @brief Gets capability information with the given account provider handle. + * + * @since_tizen 2.3 + * @param[in] account_type The account provider handle\n + * It should be given by account_type_query_* functions or account_type_foreach_account_type_from_db(). + * @param[in] callback The callback function that carries the capability name of the app ID + * @param[in] user_data The user data \n + * If you have your private data to carry into callback function, then you can use it. + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_disconnect() + */ +ACCOUNT_API int account_type_get_provider_feature_all(account_type_h account_type, provider_feature_cb callback, void* user_data); + +/** + * @brief Gets the specific label information detail of an account provider. + * + * @since_tizen 2.3 + * @param[in] account_type The account provider handle\n + * It should be given by account_type_query_* functions or account_type_foreach_account_type_from_db(). + * @param[in] locale The locale is specified as an ISO 3166 alpha-2 two letter country-code followed by ISO 639-1 for the two-letter language code.\n + * For example, "ko_KR" or "ko-kr" for Korean, "en_US" or "en-us" for American English. + * @param[out] label The label text given for the locale + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_RECORD_NOT_FOUND No label for the given locale + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_type_foreach_account_type_from_db() + * @see account_type_query_by_app_id() + */ + +ACCOUNT_API int account_type_get_label_by_locale(account_type_h account_type, const char* locale, char** label); + +/** + * @brief Gets the label information detail of an account provider. + * + * @since_tizen 2.3 + * @param[in] account_type The account provider handle\n + * It should be given by account_type_query_* functions or account_type_foreach_account_type_from_db(). + * @param[in] callback The callback function carrying the label information + * @param[in] user_data The user data to be passed to the callback function + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_type_foreach_account_type_from_db() + * @see account_type_query_by_app_id() + */ +ACCOUNT_API int account_type_get_label(account_type_h account_type, account_label_cb callback, void *user_data); + +/** + * @internal + * @brief Inserts the account provider details to the database. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @param[in] account_type The account handle which is created by account_type_create() \n + * @param[out] account_type_id The account provider ID to be assigned after inserting the account provider handle + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * @post account_disconnect() is recommended after insertion. + * + * @see account_connect() + * @see account_disconnect() + */ +ACCOUNT_API int account_type_insert_to_db(account_type_h account_type, int* account_type_id); + +/** + * @internal + * @brief Updates the account details to the account database. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @param[in] account_type The account handle which is created by account_type_create() \n + * @param[in] app_id The application ID of the account provider + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * @post account_disconnect() is recommended after update. + * + * @see account_connect() + * @see account_disconnect() + */ +ACCOUNT_API int account_type_update_to_db_by_app_id(const account_type_h account_type, const char* app_id); + +/** + * @internal + * @brief Deletes the account provider from the account database by application ID. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read \n + * %http://tizen.org/privilege/account.write + * @remarks this API need both privileges + * @param[in] app_id The application ID of account provider to be deleted + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_disconnect() + */ +ACCOUNT_API int account_type_delete_by_app_id(const char* app_id); + +/** + * @brief Retrieves the label information with your application ID. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] callback The callback function that carries label_h for label information \n + * label_h contains label info as parameter. + * @param[in] app_id The application ID to search + * @param[in] user_data The user data \n + * If you have your private data to carry into callback function, then you can use it. + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_type_query_by_app_id() + * @see account_type_foreach_account_type_from_db() + * @see account_disconnect() + */ +ACCOUNT_API int account_type_query_label_by_app_id(account_label_cb callback, const char* app_id, void *user_data ); + +/** + * @brief Retrieves the account provider information with your application ID. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] app_id The application ID to search + * @param[out] account_type The account handle which is created by account_type_create() + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_RECORD_NOT_FOUND Queried data does not exist + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_type_create() + * @see account_type_get_app_id() + * @see account_type_get_service_provider_id() + * @see account_type_get_icon_path() + * @see account_type_get_small_icon_path() + * @see account_type_get_multiple_account_support() + * @see account_type_get_label() + * @see account_type_destroy() + */ +ACCOUNT_API int account_type_query_by_app_id(const char* app_id, account_type_h *account_type); + +/** + * @brief Retrieves all account priovider information. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] callback The account provider information \n + * You can get the account information through account_type_get_* with the carried account_type_handle. + * @param[in] user_data The user data \n + * It will be carried through your callback function. + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + * @see account_type_create() + * @see account_type_get_app_id() + * @see account_type_get_service_provider_id() + * @see account_type_get_icon_path() + * @see account_type_get_small_icon_path() + * @see account_type_get_multiple_account_support() + * @see account_type_get_label() + * @see account_type_destroy() + */ +ACCOUNT_API int account_type_foreach_account_type_from_db(account_type_cb callback, void *user_data); + +/** + * @brief Retrieves the label information with the given application ID and locale. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] app_id The application ID + * @param[in] locale The locale is specified as an ISO 3166 alpha-2 two letter country-code followed by ISO 639-1 for the two-letter language code.\n + * For example, "ko_KR" or "ko-kr" for Korean, "en_US" or "en-us" for American English. + * @param[out] label The label text corresponding app_id and locale \n + * It must be free text. + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + */ +ACCOUNT_API int account_type_query_label_by_locale(const char* app_id, const char* locale, char** label); + +/** + * @brief Retrieves account provider information with the capability name. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] callback The callback function to retrieve account provider information + * @param[in] key The capability value to search account provider \n + * For example, ACCOUNT_SUPPORTS_CAPABILITY_CONTACT or "http://tizen.org/account/capability/contact" + * @param[in] user_data If you have your private data to carry into callback function, then you can use it + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_RECORD_NOT_FOUND Record not found + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_DB_FAILED Database operation failed + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_connect() + */ +ACCOUNT_API int account_type_query_by_provider_feature(account_type_cb callback, const char* key, void* user_data); + +/** + * @brief Checks whether the given app_id exists in the account provider DB. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] app_id The application ID to check + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_RECORD_NOT_FOUND Record not found + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid app ID + * @retval #ACCOUNT_ERROR_PERMISSION_DENIED DB Access fail by permission + * + * @pre This function requires an open connection to an account service by account_connect(). + * + * @see account_type_query_by_app_id() + */ +ACCOUNT_API int account_type_query_app_id_exist(const char* app_id); + + + +/* End of account provider API */ + +/** + * @brief Creates a handle for the account event subscription. + * + * @since_tizen 2.3 + * @remarks You must release @a account_subscribe handle using account_unsubscribe_notification(). + * + * @param[in] account_subscribe The account subscription handle + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_OUT_OF_MEMORY Out of Memory + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_unsubscribe_notification() + * @see account_subscribe_notification() + */ +ACCOUNT_API int account_subscribe_create(account_subscribe_h* account_subscribe); + +/** + * @brief Starts to subscribe account event through the given callback function. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @param[in] account_subscribe The account subscription handle + * @param[in] callback The callback function that is called when an account is removed and a data of account is updated from the account database \n + * It will be called with event message and account ID. + * @param[in] user_data The user_data that is delivered to callback + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_EVENT_SUBSCRIPTION_FAIL Subscription fail + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @pre account_subscribe_create() + * + * @see account_unsubscribe_notification() + * @see account_subscribe_notification() + */ +ACCOUNT_API int account_subscribe_notification(account_subscribe_h account_subscribe, account_event_cb callback, void* user_data); + +/** + * @brief Destroys the account subscribe handle and releases all its resources. + * + * @since_tizen 2.3 + * @privlevel public + * @privilege %http://tizen.org/privilege/account.read + * @remarks You must call @a account_unsubscribe_notification when you do not need to subscribe account event. + * + * @param[in] account_subscribe The account subscription handle + * + * @return @c 0 on success, + * otherwise a negative error value + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * @retval #ACCOUNT_ERROR_EVENT_SUBSCRIPTION_FAIL Unsubscription failed + * + * @see account_create() + */ +ACCOUNT_API int account_unsubscribe_notification(account_subscribe_h account_subscribe); +/** +* @} +*/ + + +#ifdef __cplusplus +} +#endif + +#endif /* __ACCOUNT_H__ */ diff --git a/include/account_PG.h b/include/account_PG.h new file mode 100755 index 0000000..c24c8c5 --- /dev/null +++ b/include/account_PG.h @@ -0,0 +1,1236 @@ +/* + * Account + * + * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Wonyoung Lee <wy1115.lee@samsung.com>, Sungchan Kim <sungchan81.kim@samsung.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/** + * + * @ingroup SLP_PG + * @defgroup Account_PG Account + + +<h1 class="pg">Introduction</h1> + <h2 class="pg">Purpose of this document</h2> + +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. + + <h2 class="pg">Scope</h2> + +The scope of this document is limited to Account API usage. + + +<h1 class="pg">Account Architecture</h1> + <h2 class="pg"> Overview</h2> + +Account is responsible for inserting, deleting, and updating Account data in order to accommodate the needs for application's Account data. +Users can access Account data without knowing DB schema, SQLite, relations of data + +<h1 class="pg">Account Features</h1> + - Similar to Sqlite3 + - Handle information of Account + + <h2 class="pg">Similar to Sqlite3</h2> +Account API is similar to Sqlite3. + + <h2 class="pg">Handle information of Account</h2> +Account supports to insert/update/delete/get/set/query information of Account. +The Information of Account includes user name, package name, email, access token, icon path, source, display name, capability informatio etc. + +<h1 class="pg">Account API Description</h1> + +you can refer @ref ACCOUNT_SVC + +<h1 class="pg">Sample Code</h1> + + <h2 class="pg">Connect to Account Database</h2> + +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 + +@code +int account_connect(void); + +int account_disconnect(void); +@endcode + + <h2 class="pg">Insert information of account</h2> + +@code +void insert_test(void) +{ + int ret = -1; + account_h account; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_create(&account); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_user_name(account, "tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "Tarun Kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung electronics"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.twiter"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE ); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "URUSA inc."); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 888); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + ret = account_set_capability(account, ACCOUNT_CAPABILITY_CONTACT, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_CALENDAR, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_VIDEO, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_EMAIL, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_STATUS_POST, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_VOIP, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_SAMSUNG_APPS, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_MOBILE_TRACKER, ACCOUNT_CAPABILITY_ENABLED); + + int account_id = -1; + ret = account_insert_to_db(account, &account_id); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + return; + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + return; +} +@endcode + + <h2 class="pg">Get account by id</h2> + +@code +bool _capability_get_callback(const char* capability_type, account_capability_state_e capability_value, void* user_data) +{ + char* test_type = capability_type; + int test_value = capability_value; + + SECURE_LOGD("_capability_get_callback test_type = : %s\n", test_type); + SECURE_LOGD("_capability_get_callback test_value = : %d\n", test_value); + return TRUE; +} + +static void _account_free_text(char *text) +{ + if (text) { + free(text); + text = NULL; + } +} + +void get_account_by_id(int account_id) +{ + int ret = - 1; + account_h account; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_query_account_by_account_id(account_id, &account); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + char *test_text = NULL; + + account_get_user_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_display_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_email_address(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_icon_path(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_source(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_package_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_domain_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_access_token(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + _account_free_text(test_text); + + account_get_user_text(handle, i, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + } + + int test_int = -1; + + account_auth_type_e auth_type; + account_get_auth_type(handle, &auth_type); + SECURE_LOGD("account_get_auth_type : %d\n", auth_type); + + account_secrecy_state_e secret; + account_get_secret(handle, &secret); + SECURE_LOGD("account_get_secret : %d\n", secret); + + account_sync_state_e sync_support; + account_get_sync_support(handle, &sync_support); + SECURE_LOGD("account_get_sync_support : %d\n", sync_support); + + for(i=0;i<USER_INT_CNT;i++) + { + test_int = -1; + account_get_user_int(handle, i, &test_int); + SECURE_LOGD("_account_get_callback : %d\n", test_int); + } + + account_get_capability(handle, _capability_get_callback, NULL); + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } +} +@endcode + + + <h2 class="pg">Get account list by user name</h2> + +@code +static void _account_free_text(char *text) +{ + if (text) { + free(text); + text = NULL; + } +} + +bool _account_get_callback(account_h handle, void* user_data) +{ + SECURE_LOGD("_account_get_callback\n"); + + char *test_text = NULL; + + account_get_user_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_display_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_email_address(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_icon_path(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_source(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_package_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_domain_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_access_token(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + _account_free_text(test_text); + + account_get_user_text(handle, i, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + } + + int test_int = -1; + + account_auth_type_e auth_type; + account_get_auth_type(handle, &auth_type); + SECURE_LOGD("account_get_auth_type : %d\n", auth_type); + + account_secrecy_state_e secret; + account_get_secret(handle, &secret); + SECURE_LOGD("account_get_secret : %d\n", secret); + + account_sync_state_e sync_support; + account_get_sync_support(handle, &sync_support); + SECURE_LOGD("account_get_sync_support : %d\n", sync_support); + + for(i=0;i<USER_INT_CNT;i++) + { + test_int = -1; + account_get_user_int(handle, i, &test_int); + SECURE_LOGD("_account_get_callback : %d\n", test_int); + } + + account_get_capability(handle, _capability_get_callback, NULL); + + return TRUE; +} + + +void get_account_list_by_user_name(char * user_name) +{ + int ret = - 1; + account_h account; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_query_account_by_user_name(_account_get_callback, user_name, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } +} +@endcode + + <h2 class="pg">Get account list by package name</h2> + +@code +static void _account_free_text(char *text) +{ + if (text) { + free(text); + text = NULL; + } +} + +bool _account_get_callback(account_h handle, void* user_data) +{ + SECURE_LOGD("_account_get_callback\n"); + + char *test_text = NULL; + + account_get_user_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_display_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_email_address(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_icon_path(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_source(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_package_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_domain_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_access_token(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + _account_free_text(test_text); + + account_get_user_text(handle, i, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + } + + int test_int = -1; + + account_auth_type_e auth_type; + account_get_auth_type(handle, &auth_type); + SECURE_LOGD("account_get_auth_type : %d\n", auth_type); + + account_secrecy_state_e secret; + account_get_secret(handle, &secret); + SECURE_LOGD("account_get_secret : %d\n", secret); + + account_sync_state_e sync_support; + account_get_sync_support(handle, &sync_support); + SECURE_LOGD("account_get_sync_support : %d\n", sync_support); + + for(i=0;i<USER_INT_CNT;i++) + { + test_int = -1; + account_get_user_int(handle, i, &test_int); + SECURE_LOGD("_account_get_callback : %d\n", test_int); + } + + account_get_capability(handle, _capability_get_callback, NULL); + + return TRUE; +} + +void get_account_list_by_package_name(char * package_name) +{ + int ret = - 1; + account_h account; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_query_account_by_package_name(_account_get_callback, package_name, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } +} +@endcode + + <h2 class="pg">Get all account list</h2> + +@code +static void _account_free_text(char *text) +{ + if (text) { + free(text); + text = NULL; + } +} + +bool _account_get_callback(account_h handle, void* user_data) +{ + SECURE_LOGD("_account_get_callback\n"); + + char *test_text = NULL; + + account_get_user_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_display_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_email_address(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_icon_path(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_source(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_package_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_domain_name(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_access_token(handle, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + _account_free_text(test_text); + + account_get_user_text(handle, i, &test_text); + SECURE_LOGD("_account_get_callback : %s\n", test_text); + } + + int test_int = -1; + + account_auth_type_e auth_type; + account_get_auth_type(handle, &auth_type); + SECURE_LOGD("account_get_auth_type : %d\n", auth_type); + + account_secrecy_state_e secret; + account_get_secret(handle, &secret); + SECURE_LOGD("account_get_secret : %d\n", secret); + + account_sync_state_e sync_support; + account_get_sync_support(handle, &sync_support); + SECURE_LOGD("account_get_sync_support : %d\n", sync_support); + + for(i=0;i<USER_INT_CNT;i++) + { + test_int = -1; + account_get_user_int(handle, i, &test_int); + SECURE_LOGD("_account_get_callback : %d\n", test_int); + } + + account_get_capability(handle, _capability_get_callback, NULL); + + return TRUE; +} + +void get_all_account() +{ + int ret = - 1; + account_h account; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_foreach_account_from_db(_account_get_callback, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } +} +@endcode + + <h2 class="pg">Update information of account by account id</h2> + +@code +void update_accont_by_id(int account_id) +{ + int ret = -1; + account_h account; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_create(&account); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_user_name(account, "update-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "update-Tarun Kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "update-Samsung electronics"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "update-tarun@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "update-com.samsung.twiter"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "update-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "update-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE ); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "update-URUSA inc."); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "update-user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 999); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + ret = account_set_capability(account, ACCOUNT_CAPABILITY_CONTACT, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_CALENDAR, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_VIDEO, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_EMAIL, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_STATUS_POST, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_VOIP, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_SAMSUNG_APPS, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_MOBILE_TRACKER, ACCOUNT_CAPABILITY_DISABLED); + + ret = account_update_to_db_by_id(account, account_id); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + return; + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } +} +@endcode + + <h2 class="pg">Update information of account by user name</h2> + +@code +void update_accont_by_user_name(char *user_name, char *package_name) +{ + int ret = -1; + account_h account; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_create(&account); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_user_name(account, "update-tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "update-Tarun Kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "update-Samsung electronics"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "update-tarun@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "update-com.samsung.twiter"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "update-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "update-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE ); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_source(account, "update-URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "update-user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 999); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + ret = account_set_capability(account, ACCOUNT_CAPABILITY_CONTACT, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_CALENDAR, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_VIDEO, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_EMAIL, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_STATUS_POST, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_VOIP, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_SAMSUNG_APPS, ACCOUNT_CAPABILITY_DISABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_MOBILE_TRACKER, ACCOUNT_CAPABILITY_DISABLED); + + ret = account_update_to_db_by_user_name(account, user_name, package_name); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + return; + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } +} +@endcode + + <h2 class="pg">Delete account by id </h2> + +@code +void delete_account_by_id(int account_id) +{ + int ret = -1; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_delete(account_id); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return; +} +@endcode + + <h2 class="pg">Update sync status by id </h2> + +@code +void update_sync_status_by_id(int account_id, const account_sync_state_e sync_status) +{ + int ret = -1; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_update_sync_status_by_id(account_id, sync_status); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return; +} +@endcode + + <h2 class="pg">Delete account by user name </h2> + +@code +void delete_account_by_user_name(char *user_name, char *package_name) +{ + int ret = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_delete_from_db_by_user_name(user_name, package_name); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d \n", __LINE__, ret); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return; +} +@endcode + + <h2 class="pg">Delete account by package name </h2> + +@code +void delete_account_by_package_name(char *package_name) +{ + int ret = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_delete_from_db_by_package_name(package_name); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d \n", __LINE__, ret); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return; +} +@endcode + + <h2 class="pg">Get account insert dbus notification </h2> + +@code +void notify_account_insert() +{ + DBusMessage* msg; + DBusConnection* conn; + DBusError err; + + SECURE_LOGD("Listening for signals\n"); + + dbus_error_init(&err); + + conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); + if (dbus_error_is_set(&err)) { + dbus_error_free(&err); + } + if (NULL == conn) { + exit(1); + } + + dbus_bus_add_match(conn, "type='signal',interface='account.signal.Type'", &err); + dbus_connection_flush(conn); + if (dbus_error_is_set(&err)) { + exit(1); + } + SECURE_LOGD("Match rule sent\n"); + + while (true) { + + dbus_connection_read_write(conn, 0); + msg = dbus_connection_pop_message(conn); + + if (NULL == msg) { + sleep(1); + continue; + } + + if (dbus_message_is_signal(msg, ACCOUNT_DBUS_SIGNAL_INTERFACE, ACCOUNT_DBUS_NOTI_NAME_INSERT)) { + SECURE_LOGD("Got Signal with name insert\n"); + } + + dbus_message_unref(msg); + } + dbus_connection_close(conn); +} +@endcode + + <h2 class="pg">Get account update dbus notification </h2> + +@code +void notify_account_update() +{ + DBusMessage* msg; + DBusConnection* conn; + DBusError err; + + SECURE_LOGD("Listening for signals\n"); + + + dbus_error_init(&err); + + conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); + if (dbus_error_is_set(&err)) { + dbus_error_free(&err); + } + if (NULL == conn) { + exit(1); + } + + dbus_bus_add_match(conn, "type='signal',interface='account.signal.Type'", &err); + dbus_connection_flush(conn); + if (dbus_error_is_set(&err)) { + exit(1); + } + SECURE_LOGD("Match rule sent\n"); + + while (true) { + + dbus_connection_read_write(conn, 0); + msg = dbus_connection_pop_message(conn); + + if (NULL == msg) { + sleep(1); + continue; + } + + if (dbus_message_is_signal(msg, ACCOUNT_DBUS_SIGNAL_INTERFACE, ACCOUNT_DBUS_NOTI_NAME_UPDATE)) { + SECURE_LOGD("Got Signal with name update\n"); + } + + dbus_message_unref(msg); + } + dbus_connection_close(conn); +} +@endcode + + <h2 class="pg">Get account delete dbus notification </h2> + +@code +void notify_account_delete() +{ + DBusMessage* msg; + DBusConnection* conn; + DBusError err; + + SECURE_LOGD("Listening for signals\n"); + + + dbus_error_init(&err); + + conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); + if (dbus_error_is_set(&err)) { + dbus_error_free(&err); + } + if (NULL == conn) { + exit(1); + } + + dbus_bus_add_match(conn, "type='signal',interface='account.signal.Type'", &err); + dbus_connection_flush(conn); + if (dbus_error_is_set(&err)) { + exit(1); + } + SECURE_LOGD("Match rule sent\n"); + + while (true) { + + dbus_connection_read_write(conn, 0); + msg = dbus_connection_pop_message(conn); + + if (NULL == msg) { + sleep(1); + continue; + } + + if (dbus_message_is_signal(msg, ACCOUNT_DBUS_SIGNAL_INTERFACE, ACCOUNT_DBUS_NOTI_NAME_DELETE)) { + SECURE_LOGD("Got Signal with name delete\n"); + } + + dbus_message_unref(msg); + } + dbus_connection_close(conn); +} +@endcode + + <h2 class="pg">Get capability by acccount id</h2> + +@code +bool _capability_get_callback(const char* capability_type, account_capability_state_e capability_value, void* user_data) +{ + char* test_type = capability_type; + int test_value = capability_value; + + SECURE_LOGD("_capability_get_callback test_type = : %s\n", test_type); + SECURE_LOGD("_capability_get_callback test_value = : %d\n", test_value); + return TRUE; +} + +void capability_by_account_id(int account_id) +{ + int ret = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_query_capability_by_account_id(_capability_get_callback, account_id, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d \n", __LINE__, ret); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + SECURE_LOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return; +} +@endcode + * @} + */ + diff --git a/include/account_internal.h b/include/account_internal.h new file mode 100644 index 0000000..7b77e47 --- /dev/null +++ b/include/account_internal.h @@ -0,0 +1,81 @@ +/* + * account + * + * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef __ACCOUNT_INTERNAL_H__ +#define __ACCOUNT_INTERNAL_H__ + +#ifdef __cplusplus +extern "C" +{ +#endif + +#ifndef ACCOUNT_INTERNAL_API +#define ACCOUNT_INTERNAL_API __attribute__ ((visibility("default"))) +#endif + +/** + * @file account_internal.h + * @brief This file contains the Account API for account management. + */ + +/** + * @internal + * @brief Start to subscribe account event through the given callback function + * + * @param[in] account_subscribe The account subscription handle + * @param[in] cb_func When an account is removed from account database. It will be called with event message and account id. + * @param[in] user_data user_data will be delivered to cb_func + * + * @return 0 on success, otherwise a negative error value. + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_EVENT_SUBSCRIPTION_FAIL Subscription fail + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_unsubscribe_notification() + * @see account_subscribe_notification() + */ +ACCOUNT_API int account_subscribe_notification_ex(account_subscribe_h account_subscribe, account_event_cb cb_func, void* user_data); + +/** + * @internal + * @brief Start to subscribe account event through the given callback function + * + * @param[in] account_subscribe The account subscription handle + * @param[in] cb_func When an account is removed from account database. It will be called with event message and account id. + * @param[in] user_data user_data will be delivered to cb_func + * + * @return 0 on success, otherwise a negative error value. + * @retval #ACCOUNT_ERROR_NONE Successful + * @retval #ACCOUNT_ERROR_EVENT_SUBSCRIPTION_FAIL Subscription fail + * @retval #ACCOUNT_ERROR_INVALID_PARAMETER Invalid parameter + * + * @see account_unsubscribe_notification() + * @see account_subscribe_notification() + */ +ACCOUNT_API int account_unsubscribe_notification_ex(account_subscribe_h account_subscribe); + +/** +* @} +*/ + +#ifdef __cplusplus +} +#endif + +#endif /* __ACCOUNT_INTERNAL_H__ */ diff --git a/libaccounts-svc.manifest b/libaccounts-svc.manifest new file mode 100755 index 0000000..d3b333c --- /dev/null +++ b/libaccounts-svc.manifest @@ -0,0 +1,19 @@ +<manifest> + <define> + <domain name="libaccounts-svc"/> + <provide> + <label name="libaccounts-svc::db"/> + <label name="libaccounts-svc::check_read"/> + </provide> + <request> + <smack request="libaccounts-svc::db" type="rw" /> + </request> + </define> + <request> + <domain name="libaccounts-svc"/> + </request> + <assign> + <filesystem path="/usr/lib/libaccounts-svc.so.0" label="_" /> + <filesystem path="/usr/lib/libaccounts-svc.so.0.2.97" label="_" /> + </assign> +</manifest> diff --git a/packaging/libaccounts-svc.spec b/packaging/libaccounts-svc.spec new file mode 100755 index 0000000..2deac97 --- /dev/null +++ b/packaging/libaccounts-svc.spec @@ -0,0 +1,115 @@ + +Name: libaccounts-svc +Summary: Account DB library +Version: 0.2.113 +Release: 1 +Group: TO_BE/FILLED_IN +License: Apache-2.0 +Source0: libaccounts-svc-%{version}.tar.gz + +BuildRequires: cmake +BuildRequires: pkgconfig(sqlite3) +BuildRequires: pkgconfig(glib-2.0) +BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(db-util) +BuildRequires: pkgconfig(capi-base-common) +BuildRequires: pkgconfig(vconf) +BuildRequires: pkgconfig(pkgmgr-info) +BuildRequires: pkgconfig(aul) +BuildRequires: pkgconfig(libsmack) + +Requires(post): /sbin/ldconfig +Requires(post): /usr/bin/sqlite3 +Requires(postun): /sbin/ldconfig + +%description +Account DB libraryXB-Public-Package: no + +%package devel +Summary: Development files for %{name} +Group: Development/Libraries +Requires: %{name} = %{version}-%{release} +%description devel +Development files for %{name} + +%prep +%setup -q + +%build +export CFLAGS+=" -Wextra -Wcast-align -Wcast-qual -Wshadow -Wwrite-strings -Wswitch-default" +export CXXFLAGS+=" -Wextra -Wcast-align -Wcast-qual -Wshadow -Wwrite-strings -Wswitch-default -Wnon-virtual-dtor -Wno-c++0x-compat" +#export CFLAGS+=" -Wno-array-bounds -Wno-ignored-qualifiers" +export CFLAGS+=" -Wno-unused-parameter -Wno-empty-body" +export CXXFLAGS+=" -Wno-unused-parameter -Wno-empty-body" + +export CFLAGS+=" -fno-omit-frame-pointer -fno-optimize-sibling-calls -fno-strict-aliasing -fno-unroll-loops -fsigned-char -fstrict-overflow -fno-common" +export CXXFLAGS+=" -fno-omit-frame-pointer -fno-optimize-sibling-calls -fno-strict-aliasing -fno-unroll-loops -fsigned-char -fstrict-overflow" + +export CFLAGS="${CFLAGS} -fPIC -fvisibility=hidden" +cmake . -DCMAKE_INSTALL_PREFIX=/usr + +make %{?jobs:-j%jobs} + +%install +rm -rf %{buildroot} +%make_install + +rm -rf %{buildroot}/usr/lib/accounts-svc + +%post +/sbin/ldconfig +if [ ! -d /opt/usr/dbspace ] +then + mkdir -p /opt/usr/dbspace +fi +if [ ! -f /opt/usr/dbspace/.account.db ] +#rm -rf /opt/usr/dbspace/.account.db* +then + sqlite3 /opt/usr/dbspace/.account.db 'PRAGMA journal_mode = PERSIST; + CREATE TABLE if not exists label (AppId TEXT, Label TEXT, Locale TEXT); + CREATE TABLE if not exists account_type (_id INTEGER PRIMARY KEY AUTOINCREMENT, AppId TEXT, + ServiceProviderId TEXT, IconPath TEXT, SmallIconPath TEXT, MultipleAccountSupport INT); + CREATE TABLE if not exists account_custom (AccountId INTEGER, AppId TEXT, Key TEXT, Value TEXT); + CREATE TABLE if not exists account (_id INTEGER PRIMARY KEY AUTOINCREMENT, user_name TEXT, email_address TEXT, display_name TEXT, icon_path TEXT, + source TEXT, package_name TEXT, access_token TEXT, domain_name TEXT, auth_type INTEGER, secret INTEGER, sync_support INTEGER, + txt_custom0 TEXT, txt_custom1 TEXT, txt_custom2 TEXT, txt_custom3 TEXT, txt_custom4 TEXT, + int_custom0 INTEGER, int_custom1 INTEGER, int_custom2 INTEGER, int_custom3 INTEGER, int_custom4 INTEGER); + CREATE TABLE if not exists capability (_id INTEGER PRIMARY KEY AUTOINCREMENT, key TEXT, value INTEGER, + package_name TEXT, user_name TEXT, account_id INTEGER, FOREIGN KEY (account_id) REFERENCES account(_id)); + CREATE TABLE if not exists provider_feature (app_id TEXT, key TEXT); +' +fi + +mkdir -p /opt/usr/share/account +chown 0:5000 /opt/usr/dbspace/.account.db +chown 0:5000 /opt/usr/dbspace/.account.db-journal + +chmod 664 /opt/usr/dbspace/.account.db +chmod 664 /opt/usr/dbspace/.account.db-journal + +#set message key value to NULL +#vconftool set -t string db/account/msg '' -g 6514 +vconftool set -t string db/account/msg '' -s libaccounts-svc -g 6514 + +#smack labeling +if [ -f /usr/lib/rpm-plugins/msm.so ] +then + chsmack -a 'libaccounts-svc::db' /opt/usr/dbspace/.account.db-journal + chsmack -a 'libaccounts-svc::db' /opt/usr/dbspace/.account.db +fi + + +%postun -p /sbin/ldconfig + + + +%files +%manifest libaccounts-svc.manifest +%defattr(-,root,root,-) +%{_libdir}/*.so.* + +%files devel +%defattr(-,root,root,-) +%{_libdir}/*.so +%{_libdir}/pkgconfig/accounts-svc.pc +%{_includedir}/*.h diff --git a/src/account.c b/src/account.c new file mode 100755 index 0000000..3aa01c5 --- /dev/null +++ b/src/account.c @@ -0,0 +1,7345 @@ +/* + * account + * + * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Wonyoung Lee <wy1115.lee@samsung.com>, Sungchan Kim <sungchan81.kim@samsung.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <fcntl.h> +#include <account.h> +#include <glib.h> +#include <db-util.h> +#include <pthread.h> +#include <account-private.h> +#include <vconf.h> +#include "account_internal.h" + +#define SAMSUNG_ACCOUNT_MANAGER + +#include <pkgmgr-info.h> +#include <aul.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/smack.h> + +#define EAS_CMDLINE "/usr/bin/eas-engine" +#define EMAIL_SERVICE_CMDLINE "/usr/bin/email-service" +#define IMS_ENGINE_CMDLINE "/usr/bin/ims-srv" +#define IMS_AGENT_CMDLINE "/usr/bin/ims-agent" +#define MDM_SERVER_CMDLINE "/usr/bin/mdm-server" + +#define RCS_APPID "com.samsung.rcs-im" +#define IMS_SERVICE_APPID "ims-service" +#define ACTIVESYNC_APPID "activesync-ui" +#define EMAIL_APPID "email-setting-efl" +#define SYNCHRONISE_APPID "setting-synchronise-efl" +#define DS_AGENT_CMDLINE "/usr/bin/oma-ds-agent" + +#define FACEBOOK_SDK_APPID "com.samsung.facebook-service" +#define FACEBOOK_APPID "com.samsung.facebook" + +#define ACCOUNT_DB_OPEN_READONLY 0 +#define ACCOUNT_DB_OPEN_READWRITE 1 + +static sqlite3* g_hAccountDB = NULL; +static int g_refCntDB = 0; +pthread_mutex_t account_mutex = PTHREAD_MUTEX_INITIALIZER; + +static char *_account_get_text(const char *text_data); +static int _account_gslist_free(GSList* list); +static int _account_glist_free(GList* list); +static const char *_account_query_table_column_text(account_stmt pStmt, int pos); +static int _account_insert_custom(account_s *account, int account_id); +static int _account_update_custom(account_s *account, int account_id); +static int _account_query_custom_by_account_id(account_custom_cb callback, int account_id, void *user_data ); +static int _account_type_update_provider_feature(account_type_s *account_type, const char* app_id); + +int _account_get_current_appid_cb(const pkgmgrinfo_appinfo_h handle, void *user_data) +{ + char* appid = NULL; + char* item = NULL; + GSList** appid_list = (GSList**)user_data; + int pkgmgr_ret = -1; + + pkgmgr_ret = pkgmgrinfo_appinfo_get_appid(handle, &appid); + + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_appinfo_get_appid(%d)", pkgmgr_ret); + } + + item = _account_get_text(appid); + *appid_list = g_slist_append(*appid_list, item); + + return 0; +} + +static inline int __read_proc(const char *path, char *buf, int size) +{ + int fd = 0, ret = 0; + + if (buf == NULL || path == NULL) { + ACCOUNT_ERROR("path and buffer is mandatory\n"); + return -1; + } + + fd = open(path, O_RDONLY); + if (fd < 0) { + ACCOUNT_ERROR("fd open error(%d)\n", fd); + return -1; + } + + ret = read(fd, buf, size - 1); + if (ret <= 0) { + ACCOUNT_ERROR("fd read error(%d)\n", fd); + close(fd); + return -1; + } else + buf[ret] = 0; + + close(fd); + + return ret; +} + +char *_account_get_proc_cmdline_bypid(int pid) +{ + char buf[128]; + int ret = 0; + + ACCOUNT_SNPRINTF(buf, sizeof(buf), "/proc/%d/cmdline", pid); + ret = __read_proc(buf, buf, sizeof(buf)); + if (ret <= 0) { + ACCOUNT_DEBUG("No proc directory (%d)\n", pid); + return NULL; + } + + return strdup(buf); +} + + +static char* _account_get_current_appid() +{ + int ret=0, pid=0; + char appid[128]={0,}; + char* appid_ret = NULL; + + pid = getpid(); + ret = aul_app_get_appid_bypid(pid, appid, sizeof(appid)); + + if(ret < 0){ + ACCOUNT_ERROR("fail to get current appid\n"); + } + + /* SLP platform core exception */ + if(strlen(appid) == 0){ + char* cmdline = NULL; + cmdline = _account_get_proc_cmdline_bypid(pid); + ACCOUNT_SLOGD("cmdline (%s)!!!!!!\n", cmdline); + if(!g_strcmp0(cmdline, EAS_CMDLINE)) { + appid_ret = _account_get_text(ACTIVESYNC_APPID); + _ACCOUNT_FREE(cmdline); + return appid_ret; + } else if (!g_strcmp0(cmdline, EMAIL_SERVICE_CMDLINE) || !g_strcmp0(cmdline, MDM_SERVER_CMDLINE)) { + appid_ret = _account_get_text(EMAIL_APPID); + _ACCOUNT_FREE(cmdline); + return appid_ret; + } else if (!g_strcmp0(cmdline, IMS_ENGINE_CMDLINE) || !g_strcmp0(cmdline, IMS_AGENT_CMDLINE)) { + if(account_type_query_app_id_exist(RCS_APPID)==ACCOUNT_ERROR_NONE){ + appid_ret = _account_get_text(RCS_APPID); + } else if(account_type_query_app_id_exist(IMS_SERVICE_APPID)==ACCOUNT_ERROR_NONE){ + appid_ret = _account_get_text(IMS_SERVICE_APPID); + } else { + appid_ret = _account_get_text(RCS_APPID); + } + _ACCOUNT_FREE(cmdline); + return appid_ret; + } else if (!g_strcmp0(cmdline, DS_AGENT_CMDLINE)) { + appid_ret = _account_get_text(SYNCHRONISE_APPID); + _ACCOUNT_FREE(cmdline); + return appid_ret; + } else { + ACCOUNT_DEBUG("No app id\n"); + _ACCOUNT_FREE(cmdline); + return NULL; + } + } + + /* temporary exception */ + if(!g_strcmp0(appid, "com.samsung.gallery")){ + appid_ret = _account_get_text("com.samsung.facebook"); + } else if(!g_strcmp0(appid, FACEBOOK_SDK_APPID)){ + appid_ret = _account_get_text(FACEBOOK_APPID); + } else { + appid_ret = _account_get_text(appid); + } + + return appid_ret; +} + +static int _account_check_account_type_with_appid_group(const char* appid, char** verified_appid) +{ + int error_code = ACCOUNT_ERROR_NOT_REGISTERED_PROVIDER; + pkgmgrinfo_appinfo_h ahandle=NULL; + pkgmgrinfo_pkginfo_h phandle=NULL; + char* package_id = NULL; + GSList* appid_list = NULL; + GSList* iter = NULL; + + if(!appid){ + ACCOUNT_ERROR("input param is null\n"); + return ACCOUNT_ERROR_NOT_REGISTERED_PROVIDER; + } + + if(!verified_appid){ + ACCOUNT_ERROR("output param is null\n"); + return ACCOUNT_ERROR_NOT_REGISTERED_PROVIDER; + } + + if(!strcmp(appid, "com.samsung.setting")){ + ACCOUNT_DEBUG("Setting exception\n"); + *verified_appid = _account_get_text("com.samsung.setting"); + return ACCOUNT_ERROR_NONE; + } + + if(!strcmp(appid, "com.samsung.samsung-account-front")){ + ACCOUNT_DEBUG("Setting exception\n"); + *verified_appid = _account_get_text("com.samsung.samsung-account-front"); + return ACCOUNT_ERROR_NONE; + } + + if(!strcmp(appid, IMS_SERVICE_APPID) || !strcmp(appid, RCS_APPID)){ + ACCOUNT_DEBUG("ims service exception\n"); + *verified_appid = _account_get_text(appid); + return ACCOUNT_ERROR_NONE; + } + + /* Get app id family which is stored in account database */ + int pkgmgr_ret = -1; + pkgmgr_ret = pkgmgrinfo_appinfo_get_appinfo(appid, &ahandle); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_appinfo_get_appinfo(%d)", pkgmgr_ret); + } + pkgmgr_ret = pkgmgrinfo_appinfo_get_pkgid(ahandle, &package_id); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_appinfo_get_pkgid(%d)", pkgmgr_ret); + } + pkgmgr_ret = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &phandle); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_pkginfo_get_pkginfo(%d)", pkgmgr_ret); + } + pkgmgr_ret = pkgmgrinfo_appinfo_get_list(phandle, PMINFO_ALL_APP, _account_get_current_appid_cb, (void *)&appid_list); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_appinfo_get_list(%d)", pkgmgr_ret); + } + + /* Compare current app id with the stored app id family */ + for(iter=appid_list;iter!=NULL;iter=g_slist_next(iter)){ + char* tmp = (char*)iter->data; + if(tmp) { + if(account_type_query_app_id_exist(tmp) == ACCOUNT_ERROR_NONE) { + *verified_appid = _account_get_text(tmp); + error_code = ACCOUNT_ERROR_NONE; + _ACCOUNT_FREE(tmp); + if( *verified_appid == NULL ) { + ACCOUNT_ERROR("Memory Allocation Failed"); + error_code = ACCOUNT_ERROR_OUT_OF_MEMORY; + } + break; + } else { + ACCOUNT_SLOGD("not matched owner group app id(%s), current appid(%s)\n", tmp, appid); + } + } + _ACCOUNT_FREE(tmp); + } + + g_slist_free(appid_list); + pkgmgr_ret = pkgmgrinfo_pkginfo_destroy_pkginfo(phandle); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_pkginfo_destroy_pkginfo(%d)", pkgmgr_ret); + } + + pkgmgr_ret = pkgmgrinfo_appinfo_destroy_appinfo(ahandle); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_appinfo_destroy_appinfo(%d)", pkgmgr_ret); + } + + return error_code; +} + +static int _account_check_appid_group_with_package_name(const char* appid, char* package_name) +{ + int error_code = ACCOUNT_ERROR_PERMISSION_DENIED; + pkgmgrinfo_appinfo_h ahandle=NULL; + pkgmgrinfo_pkginfo_h phandle=NULL; + char* package_id = NULL; + GSList* appid_list = NULL; + GSList* iter = NULL; + + if(!appid){ + ACCOUNT_ERROR("input param -appid is null\n"); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if(!package_name){ + ACCOUNT_ERROR("input param - package name is null\n"); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + /* ims-service Exception */ + if ( strcmp(appid, "ims-service") == 0 && strcmp(package_name, "ims-service") == 0 ) { + ACCOUNT_DEBUG("ims exception."); // TODO: NEED TO REMOVE, debug log. + return ACCOUNT_ERROR_NONE; + } + + /* Get app id family which is stored in account database */ + int pkgmgr_ret = -1; + pkgmgr_ret = pkgmgrinfo_appinfo_get_appinfo(appid, &ahandle); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_appinfo_get_appinfo(%d)", pkgmgr_ret); + } + pkgmgr_ret = pkgmgrinfo_appinfo_get_pkgid(ahandle, &package_id); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_appinfo_get_pkgid(%d)", pkgmgr_ret); + } + pkgmgr_ret = pkgmgrinfo_pkginfo_get_pkginfo(package_id, &phandle); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_pkginfo_get_pkginfo(%d)", pkgmgr_ret); + } + pkgmgr_ret = pkgmgrinfo_appinfo_get_list(phandle, PMINFO_ALL_APP, _account_get_current_appid_cb, (void *)&appid_list); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_appinfo_get_list(%d)", pkgmgr_ret); + } + + /* Compare current app id with the stored app id family */ + for(iter=appid_list;iter!=NULL;iter=g_slist_next(iter)){ + char* tmp = (char*)iter->data; + if(tmp) { + //ACCOUNT_ERROR("tmp(%s)package_name(%s)\n\n", tmp, package_name); // TODO: NEED TO REMOVE, debug log. + if( strcmp(tmp, package_name) == 0) { + error_code = ACCOUNT_ERROR_NONE; + _ACCOUNT_FREE(tmp); + break; + } else if ( strcmp(tmp, SAMSUNGACCOUNTFRONT_PKG_NAME) == 0 && + strcmp(package_name, SAMSUNGACCOUNT_PKG_NAME) == 0 ) { + /* Samung Account Exception */ + error_code = ACCOUNT_ERROR_NONE; + _ACCOUNT_FREE(tmp); + break; + } else { + ACCOUNT_SLOGD("not matched owner group app id(%s), current appid(%s)\n", tmp, appid); + } + } + _ACCOUNT_FREE(tmp); + } + + g_slist_free(appid_list); + pkgmgr_ret = pkgmgrinfo_pkginfo_destroy_pkginfo(phandle); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_pkginfo_destroy_pkginfo(%d)", pkgmgr_ret); + } + + pkgmgr_ret = pkgmgrinfo_appinfo_destroy_appinfo(ahandle); + if( pkgmgr_ret != PMINFO_R_OK ){ + ACCOUNT_DEBUG("pkgmgrinfo_appinfo_destroy_appinfo(%d)", pkgmgr_ret); + } + + return error_code; +} + +static const char *_account_db_err_msg() +{ + return sqlite3_errmsg(g_hAccountDB); +} + +static int _account_db_err_code() +{ + return sqlite3_errcode(g_hAccountDB); +} + +static void _account_insert_delete_update_notification_send(char *noti_name) +{ + if (!noti_name) { + ACCOUNT_ERROR("Noti Name is NULL!!!!!!\n"); + return; + } + + ACCOUNT_DEBUG("noti_type = %s", noti_name); + + if (vconf_set_str(VCONFKEY_ACCOUNT_MSG_STR, noti_name) != 0) { + ACCOUNT_ERROR("Vconf MSG Str set FAILED !!!!!!\n");; + } +} + +static int _account_get_record_count(char* query) +{ + int rc = -1; + int ncount = 0; + account_stmt pStmt = NULL; + + if(!query){ + ACCOUNT_ERROR("NULL query\n"); + return ACCOUNT_ERROR_QUERY_SYNTAX_ERROR; + } + + if(!g_hAccountDB){ + ACCOUNT_ERROR("DB is not opened\n"); + return ACCOUNT_ERROR_DB_NOT_OPENED; + } + + rc = sqlite3_prepare_v2(g_hAccountDB, query, strlen(query), &pStmt, NULL); + + if (SQLITE_BUSY == rc){ + ACCOUNT_ERROR("sqlite3_prepare_v2() failed(%d, %s).", rc, _account_db_err_msg()); + sqlite3_finalize(pStmt); + return ACCOUNT_ERROR_DATABASE_BUSY; + } else if (SQLITE_OK != rc) { + ACCOUNT_ERROR("sqlite3_prepare_v2() failed(%d, %s).", rc, _account_db_err_msg()); + sqlite3_finalize(pStmt); + return ACCOUNT_ERROR_DB_FAILED; + } + + rc = sqlite3_step(pStmt); + if (SQLITE_BUSY == rc) { + ACCOUNT_ERROR("sqlite3_step() failed(%d, %s).", rc, _account_db_err_msg()); + sqlite3_finalize(pStmt); + return ACCOUNT_ERROR_DATABASE_BUSY; + } else if (SQLITE_ROW != rc) { + ACCOUNT_ERROR("sqlite3_step() failed(%d, %s).", rc, _account_db_err_msg()); + sqlite3_finalize(pStmt); + return ACCOUNT_ERROR_DB_FAILED; + } + + ncount = sqlite3_column_int(pStmt, 0); + + sqlite3_finalize(pStmt); + + return ncount; +} + +static int _account_execute_query(const char *query) +{ + int rc = -1; + char* pszErrorMsg = NULL; + + if(!query){ + ACCOUNT_ERROR("NULL query\n"); + return ACCOUNT_ERROR_QUERY_SYNTAX_ERROR; + } + + if(!g_hAccountDB){ + ACCOUNT_ERROR("DB is not opened\n"); + return ACCOUNT_ERROR_DB_NOT_OPENED; + } + + rc = sqlite3_exec(g_hAccountDB, query, NULL, NULL, &pszErrorMsg); + if (SQLITE_OK != rc) { + ACCOUNT_ERROR("sqlite3_exec rc(%d) query(%s) failed(%s).", rc, query, pszErrorMsg); + sqlite3_free(pszErrorMsg); + } + + return rc; +} + +static int _account_begin_transaction(void) +{ + int ret = -1; + + ret = _account_execute_query("BEGIN IMMEDIATE TRANSACTION"); + + if (ret == SQLITE_BUSY){ + ACCOUNT_ERROR(" sqlite3 busy = %d", ret); + return ACCOUNT_ERROR_DATABASE_BUSY; + } else if(ret != SQLITE_OK) { + ACCOUNT_ERROR("_account_svc_begin_transaction fail :: %d", ret); + return ACCOUNT_ERROR_DB_FAILED; + } + + return ACCOUNT_ERROR_NONE; +} + +static int _account_end_transaction(bool is_success) +{ + int ret = -1; + + if (is_success == true) { + ret = _account_execute_query("COMMIT TRANSACTION"); + } else { + ret = _account_execute_query("ROLLBACK TRANSACTION"); + } + + if(ret == SQLITE_PERM){ + ACCOUNT_ERROR("Account permission denied :: %d", ret); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (ret == SQLITE_BUSY){ + ACCOUNT_DEBUG(" sqlite3 busy = %d", ret); + return ACCOUNT_ERROR_DATABASE_BUSY; + } + + if (ret != SQLITE_OK) { + ACCOUNT_ERROR("_account_svc_end_transaction fail :: %d", ret); + return ACCOUNT_ERROR_DB_FAILED; + } + + return ACCOUNT_ERROR_NONE; +} + +static bool _account_check_add_more_account(const char* app_id) +{ + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + + ACCOUNT_RETURN_VAL((app_id != 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE AppId = '%s' and MultipleAccountSupport = 1", ACCOUNT_TYPE_TABLE, app_id); + rc = _account_get_record_count(query); + + /* multiple account support case */ + if(rc > 0) { + ACCOUNT_SLOGD("app id (%s) supports multiple account. rc(%d)\n", app_id, rc); + return TRUE; + } + + /* multiple account not support case */ + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE package_name = '%s'", ACCOUNT_TABLE, app_id); + rc = _account_get_record_count(query); + + if(rc <= 0) { + ACCOUNT_SLOGD("app id (%s) supports single account. and there is no account of the app id\n", app_id); + return TRUE; + } + + return FALSE; +} + +static int _account_create_all_tables(void) +{ + int rc = -1; + int error_code = ACCOUNT_ERROR_NONE; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + + ACCOUNT_DEBUG("create all table - BEGIN"); + ACCOUNT_MEMSET(query, 0, sizeof(query)); + + /*Create the account table*/ + ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')", ACCOUNT_TABLE); + rc = _account_get_record_count(query); + if (rc <= 0) { + rc = _account_execute_query(ACCOUNT_SCHEMA); + if(rc == SQLITE_BUSY) return ACCOUNT_ERROR_DATABASE_BUSY; + ACCOUNT_RETURN_VAL((SQLITE_OK == rc), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_execute_query(%s) failed(%d, %s).\n", ACCOUNT_SCHEMA, rc, _account_db_err_msg())); + } + + /*Create capability table*/ + ACCOUNT_MEMSET(query, 0, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')", CAPABILITY_TABLE); + rc = _account_get_record_count(query); + if (rc <= 0) { + rc = _account_execute_query(CAPABILITY_SCHEMA); + if(rc == SQLITE_BUSY) return ACCOUNT_ERROR_DATABASE_BUSY; + ACCOUNT_RETURN_VAL((SQLITE_OK == rc), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_execute_query(%s) failed(%d, %s).\n", CAPABILITY_SCHEMA, rc, _account_db_err_msg())); + } + + /* Create account custom table */ + ACCOUNT_MEMSET(query, 0, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')", ACCOUNT_CUSTOM_TABLE); + rc = _account_get_record_count(query); + if (rc <= 0) { + rc = _account_execute_query(ACCOUNT_CUSTOM_SCHEMA); + if(rc == SQLITE_BUSY) return ACCOUNT_ERROR_DATABASE_BUSY; + ACCOUNT_RETURN_VAL((SQLITE_OK == rc), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_execute_query(%s) failed(%d, %s).\n", query, rc, _account_db_err_msg())); + } + + /* Create account type table */ + ACCOUNT_MEMSET(query, 0, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')", ACCOUNT_TYPE_TABLE); + rc = _account_get_record_count(query); + if (rc <= 0) { + rc = _account_execute_query(ACCOUNT_TYPE_SCHEMA); + if(rc == SQLITE_BUSY) return ACCOUNT_ERROR_DATABASE_BUSY; + ACCOUNT_RETURN_VAL((SQLITE_OK == rc), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_execute_query(%s) failed(%d, %s).\n", ACCOUNT_TYPE_SCHEMA, rc, _account_db_err_msg())); + } + + /* Create label table */ + ACCOUNT_MEMSET(query, 0, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')", LABEL_TABLE); + rc = _account_get_record_count(query); + if (rc <= 0) { + rc = _account_execute_query(LABEL_SCHEMA); + if(rc == SQLITE_BUSY) return ACCOUNT_ERROR_DATABASE_BUSY; + ACCOUNT_RETURN_VAL((SQLITE_OK == rc), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_execute_query(%s) failed(%d, %s).\n", LABEL_SCHEMA, rc, _account_db_err_msg())); + } + + /* Create account feature table */ + ACCOUNT_MEMSET(query, 0, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s')", PROVIDER_FEATURE_TABLE); + rc = _account_get_record_count(query); + if (rc <= 0) { + rc = _account_execute_query(PROVIDER_FEATURE_SCHEMA); + if(rc == SQLITE_BUSY) return ACCOUNT_ERROR_DATABASE_BUSY; + ACCOUNT_RETURN_VAL((SQLITE_OK == rc), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_execute_query(%s) failed(%d, %s).\n", PROVIDER_FEATURE_SCHEMA, rc, _account_db_err_msg())); + } + + ACCOUNT_DEBUG("create all table - END"); + return error_code; +} + +static int _account_check_is_all_table_exists() +{ + int rc = 0; + char query[ACCOUNT_SQL_LEN_MAX] = {0,}; + ACCOUNT_MEMSET(query, 0, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from sqlite_master where name in ('%s', '%s', '%s', '%s', '%s', '%s')", + ACCOUNT_TABLE, CAPABILITY_TABLE, ACCOUNT_CUSTOM_TABLE, ACCOUNT_TYPE_TABLE, LABEL_TABLE, PROVIDER_FEATURE_TABLE); + rc = _account_get_record_count(query); + + if (rc != ACCOUNT_TABLE_TOTAL_COUNT) { + ACCOUNT_ERROR("Table count is not matched rc=%d\n", rc); + } + + return rc; +} + +static int _account_db_open(int mode) +{ + int rc = 0; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + + if (!g_hAccountDB) { + if(mode == ACCOUNT_DB_OPEN_READWRITE) + rc = db_util_open(ACCOUNT_DB_NAME, &g_hAccountDB, DB_UTIL_REGISTER_HOOK_METHOD); + else if(mode == ACCOUNT_DB_OPEN_READONLY) + rc = db_util_open_with_options(ACCOUNT_DB_NAME, &g_hAccountDB, SQLITE_OPEN_READONLY, NULL); + else + return ACCOUNT_ERROR_DB_NOT_OPENED; + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + ACCOUNT_RETURN_VAL((rc != SQLITE_PERM), {}, ACCOUNT_ERROR_PERMISSION_DENIED, ("Account permission denied rc : %d", rc)); + ACCOUNT_RETURN_VAL((rc == SQLITE_OK), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected. rc : %d", rc)); + g_refCntDB++; + } else { + g_refCntDB++; + } + + ACCOUNT_RETURN_VAL((rc == SQLITE_OK), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("busy handler fail. rc : %d", rc)); + + return ACCOUNT_ERROR_NONE; +} + +static int _account_db_close(void) +{ + int rc = 0; + int ret = -1; + + if (g_hAccountDB) { + if (g_refCntDB > 0) { + g_refCntDB--; + } + if (g_refCntDB == 0) { + rc = db_util_close(g_hAccountDB); + if( rc == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(SQLITE_PERM)"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } else if ( rc == SQLITE_BUSY ){ + ACCOUNT_ERROR( "database busy"); + return ACCOUNT_ERROR_DATABASE_BUSY; + } + ACCOUNT_RETURN_VAL((rc == SQLITE_OK), {}, ACCOUNT_ERROR_DB_FAILED, ("The database isn't connected. rc : %d", rc)); + g_hAccountDB = NULL; + } + ret = ACCOUNT_ERROR_NONE; + } else { + ACCOUNT_ERROR( "_account_svc_db_close: No handle(). refcnt=%d ", g_refCntDB); + ret = ACCOUNT_ERROR_DB_FAILED; + } + + return ret; +} + +static int _account_connect(int mode) +{ + int error_code = ACCOUNT_ERROR_NONE; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + pthread_mutex_lock(&account_mutex); + + error_code = _account_db_open(mode); + if (ACCOUNT_ERROR_NONE != error_code) { + ACCOUNT_ERROR("The database isn't connected.\n"); + pthread_mutex_unlock(&account_mutex); + + if(error_code == ACCOUNT_ERROR_PERMISSION_DENIED) + return error_code; + else + return ACCOUNT_ERROR_DB_NOT_OPENED; + } + + int rc = _account_check_is_all_table_exists(); + + if ( rc < 0 ){ + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR("rc(%d)", rc); + return rc; + } else if (rc == ACCOUNT_TABLE_TOTAL_COUNT){ + // do nothing + ACCOUNT_DEBUG("Tables OK"); + } else { + error_code = _account_create_all_tables(); + } + + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_connect (void) +{ + return _account_connect(ACCOUNT_DB_OPEN_READWRITE); +} + +ACCOUNT_API int account_connect_readonly (void) +{ + return _account_connect(ACCOUNT_DB_OPEN_READONLY); +} + +static int _account_disconnect(void) +{ + int error_code = ACCOUNT_ERROR_NONE; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + pthread_mutex_lock(&account_mutex); + + error_code = _account_db_close(); + pthread_mutex_unlock(&account_mutex); + + return error_code; +} + +ACCOUNT_API int account_disconnect (void) +{ + return _account_disconnect(); +} + +static int _account_free_capability_items(account_capability_s *data) +{ + _ACCOUNT_FREE(data->type); + _ACCOUNT_FREE(data->package_name); + _ACCOUNT_FREE(data->user_name); + + return ACCOUNT_ERROR_NONE; +} + +static int _account_custom_item_free(account_custom_s *data) +{ + _ACCOUNT_FREE(data->app_id); + _ACCOUNT_FREE(data->key); + _ACCOUNT_FREE(data->value); + + return ACCOUNT_ERROR_NONE; +} + +static int _account_custom_gslist_free(GSList* list) +{ + if(!list){ + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + GSList* iter; + + for (iter = list; iter != NULL; iter = g_slist_next(iter)) { + account_custom_s *custom_data = (account_custom_s*)iter->data; + _account_custom_item_free(custom_data); + _ACCOUNT_FREE(custom_data); + } + + g_slist_free(list); + list = NULL; + + return ACCOUNT_ERROR_NONE; +} + +static int _account_free_account_items(account_s *data) +{ + _ACCOUNT_FREE(data->user_name); + _ACCOUNT_FREE(data->email_address); + _ACCOUNT_FREE(data->display_name); + _ACCOUNT_FREE(data->icon_path); + _ACCOUNT_FREE(data->source); + _ACCOUNT_FREE(data->package_name); + _ACCOUNT_FREE(data->domain_name); + _ACCOUNT_FREE(data->access_token); + + int i; + for(i=0;i<USER_TXT_CNT;i++) + _ACCOUNT_FREE(data->user_data_txt[i]); + + _account_gslist_free(data->capablity_list); + _account_glist_free(data->account_list); + _account_custom_gslist_free(data->custom_list); + + return ACCOUNT_ERROR_NONE; +} + +static int _account_gslist_free(GSList* list) +{ + if(!list){ + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + GSList* iter; + + for (iter = list; iter != NULL; iter = g_slist_next(iter)) { + account_capability_s *cap_data = (account_capability_s*)iter->data; + _account_free_capability_items(cap_data); + _ACCOUNT_FREE(cap_data); + } + + g_slist_free(list); + list = NULL; + + return ACCOUNT_ERROR_NONE; +} + +static int _account_glist_free(GList* list) +{ + if(!list){ + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + GList* iter; + + for (iter = list; iter != NULL; iter = g_list_next(iter)) { + account_s *account_record = (account_s*)iter->data; + _account_free_account_items(account_record); + _ACCOUNT_FREE(account_record); + } + + g_list_free(list); + list = NULL; + + return ACCOUNT_ERROR_NONE; +} + +static gboolean _account_check_duplicated(account_s *data) +{ +#if 0 + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int count = 0; + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from %s where user_name='%s' and package_name='%s'" + , ACCOUNT_TABLE, data->user_name, data->package_name); + + count = _account_get_record_count(query); + if (count > 0) { + ACCOUNT_SLOGI("_account_check_duplicated : duplicated %d account(s) exist!, user_name=%s, domain_name=%s\n", + count, data->user_name, data->domain_name ); + return TRUE; + } +#endif + return FALSE; + +} + +static int _account_get_next_sequence(const char *pszName) +{ + int rc = 0; + account_stmt pStmt = NULL; + int max_seq = 0; + char szQuery[ACCOUNT_SQL_LEN_MAX] = {0,}; + + ACCOUNT_MEMSET(szQuery, 0x00, sizeof(szQuery)); + ACCOUNT_SNPRINTF(szQuery, sizeof(szQuery), "SELECT max(seq) FROM %s where name = '%s' ", ACCOUNT_SQLITE_SEQ, pszName); + rc = sqlite3_prepare_v2(g_hAccountDB, szQuery, strlen(szQuery), &pStmt, NULL); + if (SQLITE_OK != rc) { + ACCOUNT_SLOGE("sqlite3_prepare_v2() failed(%d, %s).", rc, _account_db_err_msg()); + sqlite3_finalize(pStmt); + return ACCOUNT_ERROR_DB_FAILED; + } + + rc = sqlite3_step(pStmt); + max_seq = sqlite3_column_int(pStmt, 0); + max_seq++; + + /*Finalize Statement*/ + rc = sqlite3_finalize(pStmt); + pStmt = NULL; + + return max_seq; +} + +static account_stmt _account_prepare_query(char *query) +{ + int rc = -1; + account_stmt pStmt = NULL; + + ACCOUNT_RETURN_VAL((query != NULL), {}, NULL, ("query is NULL")); + + rc = sqlite3_prepare_v2(g_hAccountDB, query, strlen(query), &pStmt, NULL); + + ACCOUNT_RETURN_VAL((SQLITE_OK == rc), {}, NULL, ("sqlite3_prepare_v2(%s) failed(%s).", query, _account_db_err_msg())); + + return pStmt; +} + +static int _account_query_bind_int(account_stmt pStmt, int pos, int num) +{ + if(!pStmt){ + ACCOUNT_ERROR("statement is null"); + return -1; + } + + if(pos < 0){ + ACCOUNT_ERROR("invalid pos"); + return -1; + } + + return sqlite3_bind_int(pStmt, pos, num); +} + +static int _account_query_bind_text(account_stmt pStmt, int pos, const char *str) +{ + if(!pStmt){ + ACCOUNT_ERROR("statement is null"); + return -1; + } + + if(str) + return sqlite3_bind_text(pStmt, pos, (const char*)str, strlen(str), SQLITE_STATIC); + else + return sqlite3_bind_null(pStmt, pos); +} + +static int _account_convert_account_to_sql(account_s *account, account_stmt hstmt, char *sql_value) +{ + int count = 1; + + /*Caution : Keep insert query orders.*/ + + /* 1. user name*/ + _account_query_bind_text(hstmt, count++, (char*)account->user_name); + + /* 2. email address*/ + _account_query_bind_text(hstmt, count++, (char*)account->email_address); + + /* 3. display name*/ + _account_query_bind_text(hstmt, count++, (char*)account->display_name); + + /* 4. icon path*/ + _account_query_bind_text(hstmt, count++, (char*)account->icon_path); + + /* 5. source*/ + _account_query_bind_text(hstmt, count++, (char*)account->source); + + /* 6. package name*/ + _account_query_bind_text(hstmt, count++, (char*)account->package_name); + + /* 7. access token*/ + _account_query_bind_text(hstmt, count++, (char*)account->access_token); + + /* 8. domain name*/ + _account_query_bind_text(hstmt, count++, (char*)account->domain_name); + + /* 9. auth type*/ + _account_query_bind_int(hstmt, count++, account->auth_type); + + /* 10. secret */ + _account_query_bind_int(hstmt, count++, account->secret); + + /* 11. sync_support */ + _account_query_bind_int(hstmt, count++, account->sync_support); + + int i; + + /* 12. user text*/ + for(i=0; i< USER_TXT_CNT; i++) + _account_query_bind_text(hstmt, count++, (char*)account->user_data_txt[i]); + + /* 13. user integer */ + for(i=0; i< USER_INT_CNT; i++) + _account_query_bind_int(hstmt, count++, account->user_data_int[i]); + + return count; +} + +static int _account_query_finalize(account_stmt pStmt) +{ + int rc = -1; + + if (!pStmt) { + ACCOUNT_ERROR( "pStmt is NULL"); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + rc = sqlite3_finalize(pStmt); + if (rc == SQLITE_BUSY){ + ACCOUNT_ERROR(" sqlite3 busy = %d", rc); + return ACCOUNT_ERROR_DATABASE_BUSY; + } else if (rc != SQLITE_OK) { + ACCOUNT_ERROR( "sqlite3_finalize fail, rc : %d, db_error : %s\n", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_DB_FAILED; + } + + return ACCOUNT_ERROR_NONE; +} + +static int _account_query_step(account_stmt pStmt) +{ + if(!pStmt){ + ACCOUNT_ERROR( "pStmt is NULL"); + return -1; + } + + return sqlite3_step(pStmt); +} + +static int _account_execute_insert_query(account_s *account) +{ + int rc = 0; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + + /* check whether app id exist in account type db */ + + if (!account->user_name && !account->display_name && !account->email_address) { + ACCOUNT_ERROR("Mandetory fields is NULL. At least one field is required among username, display name, email address\n"); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s( user_name, email_address , display_name , icon_path , source , package_name , " + "access_token , domain_name , auth_type , secret , sync_support , txt_custom0, txt_custom1, txt_custom2, txt_custom3, txt_custom4, " + "int_custom0, int_custom1, int_custom2, int_custom3, int_custom4, txt_custom0 ) values " // to do urusa + "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? , ?, ?)", ACCOUNT_TABLE); + + hstmt = _account_prepare_query(query); + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg())); + + _account_convert_account_to_sql(account, hstmt, query); + + rc = _account_query_step(hstmt); + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + + if( _account_db_err_code() == SQLITE_PERM ) + error_code = ACCOUNT_ERROR_PERMISSION_DENIED; + else + error_code = ACCOUNT_ERROR_DB_FAILED; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + return error_code; +} + +static int _account_insert_capability(account_s *account, int account_id) +{ + int rc, count = 1; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + account_stmt hstmt = NULL; + + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + + if (g_slist_length( account->capablity_list)==0) { + ACCOUNT_DEBUG( "_account_insert_capability, no capability\n"); + return ACCOUNT_ERROR_NONE; + } + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_id); + + rc = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + if (rc <= 0) { + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + /* insert query*/ + + GSList *iter; + + for (iter = account->capablity_list; iter != NULL; iter = g_slist_next(iter)) { + int ret; + count = 1; + + account_capability_s* cap_data = NULL; + cap_data = (account_capability_s*)iter->data; + + ACCOUNT_SLOGD("cap_data->type = %s, cap_data->value = %d \n", cap_data->type, cap_data->value); + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(key, value, package_name, user_name, account_id) VALUES " + "(?, ?, ?, ?, ?) ", CAPABILITY_TABLE); + hstmt = _account_prepare_query(query); + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg())); + + ret = _account_query_bind_text(hstmt, count++, cap_data->type); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_int(hstmt, count++, cap_data->value); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)account->package_name); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)account->user_name); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_int(hstmt, count++, (int)account_id); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail")); + + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + break; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + } + + return ACCOUNT_ERROR_NONE; +} + +static int _account_update_capability(account_s *account, int account_id) +{ + int rc, count = 1; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + account_stmt hstmt = NULL; + + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + + if (g_slist_length( account->capablity_list)==0) { + ACCOUNT_ERROR( "_account_update_capability, no capability\n"); + return ACCOUNT_ERROR_NONE; + } + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_id); + + rc = _account_get_record_count(query); + + if (rc <= 0) { + ACCOUNT_SLOGI( "_account_update_capability : related account item is not existed rc=%d , %s", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE account_id=? ", CAPABILITY_TABLE); + hstmt = _account_prepare_query(query); + count = 1; + _account_query_bind_int(hstmt, count++, (int)account_id); + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_DB_FAILED; + } + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + GSList *iter; + + for (iter = account->capablity_list; iter != NULL; iter = g_slist_next(iter)) { + int ret; + count = 1; + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(key, value, package_name, user_name, account_id) VALUES " + "(?, ?, ?, ?, ?) ", CAPABILITY_TABLE); + + hstmt = _account_prepare_query(query); + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg())); + + account_capability_s* cap_data = NULL; + cap_data = (account_capability_s*)iter->data; + + ret = _account_query_bind_text(hstmt, count++, cap_data->type); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_int(hstmt, count++, cap_data->value); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)account->package_name); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)account->user_name); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_int(hstmt, count++, (int)account_id); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail")); + + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + break; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + } + + return ACCOUNT_ERROR_NONE; +} + +static int _account_update_capability_by_user_name(account_s *account, const char *user_name, const char *package_name ) +{ + int rc, count = 1; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + account_stmt hstmt = NULL; + + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + + if (g_slist_length( account->capablity_list)==0) { + ACCOUNT_ERROR( "_account_update_capability_by_user_name, no capability\n"); + return ACCOUNT_ERROR_NONE; + } + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where package_name= '%s' and user_name='%s'", ACCOUNT_TABLE, package_name, user_name); + + rc = _account_get_record_count(query); + + if (rc <= 0) { + ACCOUNT_SLOGI( "_account_update_capability_by_user_name : related account item is not existed rc=%d , %s ", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE package_name=? and user_name=? ", CAPABILITY_TABLE); + hstmt = _account_prepare_query(query); + count = 1; + _account_query_bind_text(hstmt, count++, (char*)account->package_name); + _account_query_bind_text(hstmt, count++, (char*)account->user_name); + rc = _account_query_step(hstmt); + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_DB_FAILED; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + GSList* iter; + + for (iter = account->capablity_list; iter != NULL; iter = g_slist_next(iter)) { + int ret; + count = 1; + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(key, value, package_name, user_name, account_id) VALUES " + "(?, ?, ?, ?, ?) ", CAPABILITY_TABLE); + + hstmt = _account_prepare_query(query); + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg())); + + account_capability_s* cap_data = NULL; + cap_data = (account_capability_s*)iter->data; + + ret = _account_query_bind_text(hstmt, count++, cap_data->type); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_int(hstmt, count++, cap_data->value); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)account->package_name); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)account->user_name); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_int(hstmt, count++, (int)account->id); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail")); + + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + break; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + } + + return ACCOUNT_ERROR_NONE; +} + +static int _account_query_table_column_int(account_stmt pStmt, int pos) +{ + if(!pStmt){ + ACCOUNT_ERROR("statement is null"); + return -1; + } + + if(pos < 0){ + ACCOUNT_ERROR("invalid pos"); + return -1; + } + + return sqlite3_column_int(pStmt, pos); +} + +static const char *_account_query_table_column_text(account_stmt pStmt, int pos) +{ + if(!pStmt){ + ACCOUNT_ERROR("statement is null"); + return NULL; + } + + if(pos < 0){ + ACCOUNT_ERROR("invalid pos"); + return NULL; + } + + return (const char *)sqlite3_column_text(pStmt, pos); +} + +static void _account_db_data_to_text(const char *textbuf, char **output) +{ + if (textbuf && strlen(textbuf)>0) { + if (*output) { + free(*output); + *output = NULL; + } + *output = strdup(textbuf); + } +} + +static void _account_convert_column_to_account(account_stmt hstmt, account_s *account_record) +{ + const char *textbuf = NULL; + + account_record->id = _account_query_table_column_int(hstmt, ACCOUNT_FIELD_ID); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_USER_NAME); + _account_db_data_to_text(textbuf, &(account_record->user_name)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_EMAIL_ADDRESS); + _account_db_data_to_text(textbuf, &(account_record->email_address)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_DISPLAY_NAME); + _account_db_data_to_text(textbuf, &(account_record->display_name)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_ICON_PATH); + _account_db_data_to_text(textbuf, &(account_record->icon_path)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_SOURCE); + _account_db_data_to_text(textbuf, &(account_record->source)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_PACKAGE_NAME); + _account_db_data_to_text(textbuf, &(account_record->package_name)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_ACCESS_TOKEN); + _account_db_data_to_text(textbuf, &(account_record->access_token)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_DOMAIN_NAME); + _account_db_data_to_text(textbuf, &(account_record->domain_name)); + + account_record->auth_type = _account_query_table_column_int(hstmt, ACCOUNT_FIELD_AUTH_TYPE); + + account_record->secret = _account_query_table_column_int(hstmt, ACCOUNT_FIELD_SECRET); + + account_record->sync_support = _account_query_table_column_int(hstmt, ACCOUNT_FIELD_SYNC_SUPPORT); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_USER_TEXT_0); + _account_db_data_to_text(textbuf, &(account_record->user_data_txt[0])); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_USER_TEXT_1); + _account_db_data_to_text(textbuf, &(account_record->user_data_txt[1])); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_USER_TEXT_2); + _account_db_data_to_text(textbuf, &(account_record->user_data_txt[2])); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_USER_TEXT_3); + _account_db_data_to_text(textbuf, &(account_record->user_data_txt[3])); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_FIELD_USER_TEXT_4); + _account_db_data_to_text(textbuf, &(account_record->user_data_txt[4])); + + account_record->user_data_int[0] = _account_query_table_column_int(hstmt, ACCOUNT_FIELD_USER_INT_0); + account_record->user_data_int[1] = _account_query_table_column_int(hstmt, ACCOUNT_FIELD_USER_INT_1); + account_record->user_data_int[2] = _account_query_table_column_int(hstmt, ACCOUNT_FIELD_USER_INT_2); + account_record->user_data_int[3] = _account_query_table_column_int(hstmt, ACCOUNT_FIELD_USER_INT_3); + account_record->user_data_int[4] = _account_query_table_column_int(hstmt, ACCOUNT_FIELD_USER_INT_4); +} + +static void _account_convert_column_to_capability(account_stmt hstmt, account_capability_s *capability_record) +{ + const char *textbuf = NULL; + + capability_record->id = _account_query_table_column_int(hstmt, CAPABILITY_FIELD_ID); + + textbuf = _account_query_table_column_text(hstmt, CAPABILITY_FIELD_KEY); + _account_db_data_to_text(textbuf, &(capability_record->type)); + + capability_record->value = _account_query_table_column_int(hstmt, CAPABILITY_FIELD_VALUE); + + textbuf = _account_query_table_column_text(hstmt, CAPABILITY_FIELD_PACKAGE_NAME); + _account_db_data_to_text(textbuf, &(capability_record->package_name)); + + textbuf = _account_query_table_column_text(hstmt, CAPABILITY_FIELD_USER_NAME); + _account_db_data_to_text(textbuf, &(capability_record->user_name)); + + capability_record->account_id = _account_query_table_column_int(hstmt, CAPABILITY_FIELD_ACCOUNT_ID); +} + +static void _account_convert_column_to_custom(account_stmt hstmt, account_custom_s *custom_record) +{ + const char *textbuf = NULL; + + custom_record->account_id = _account_query_table_column_int(hstmt, ACCOUNT_CUSTOM_FIELD_ACCOUNT_ID); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_CUSTOM_FIELD_APP_ID); + _account_db_data_to_text(textbuf, &(custom_record->app_id)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_CUSTOM_FIELD_KEY); + _account_db_data_to_text(textbuf, &(custom_record->key)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_CUSTOM_FIELD_VALUE); + _account_db_data_to_text(textbuf, &(custom_record->value)); +} + +bool _account_get_capability_text_cb(const char* capability_type, account_capability_state_e capability_value, void *user_data) +{ + account_s *data = (account_s*)user_data; + + account_capability_s *cap_data = (account_capability_s*)malloc(sizeof(account_capability_s)); + + if (cap_data == NULL) + return FALSE; + ACCOUNT_MEMSET(cap_data, 0, sizeof(account_capability_s)); + + cap_data->type = _account_get_text(capability_type); + cap_data->value = capability_value; + + data->capablity_list = g_slist_append(data->capablity_list, (gpointer)cap_data); + + return TRUE; +} + + +bool _account_get_custom_text_cb(char* key, char* value, void *user_data) +{ + account_s *data = (account_s*)user_data; + + account_custom_s *custom_data = (account_custom_s*)malloc(sizeof(account_custom_s)); + + if (custom_data == NULL) { + ACCOUNT_DEBUG("_account_get_custom_text_cb :: malloc fail\n"); + return FALSE; + } + ACCOUNT_MEMSET(custom_data, 0, sizeof(account_custom_s)); + + custom_data->account_id = data->id; + custom_data->app_id = _account_get_text(data->package_name); + custom_data->key = _account_get_text(key); + custom_data->value = _account_get_text(value); + + data->custom_list = g_slist_append(data->custom_list, (gpointer)custom_data); + + return TRUE; +} + + +static char *_account_get_text(const char *text_data) +{ + char *text_value = NULL; + + if (text_data != NULL) { + text_value = strdup(text_data); + } + return text_value; +} + +static int _account_compare_old_record_by_user_name(account_s *new_account, const char* user_name, const char* package_name) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + account_s *old_account = NULL; + + ACCOUNT_RETURN_VAL((new_account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT IS NULL")); + ACCOUNT_RETURN_VAL((user_name != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("USER NAME IS NULL")); + ACCOUNT_RETURN_VAL((package_name != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("PACKAGE NAME IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + old_account = (account_s*)calloc(1, sizeof(account_s)); + if(!old_account) { + ACCOUNT_FATAL("Memory alloc fail\n"); + return ACCOUNT_ERROR_OUT_OF_MEMORY; + } + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE user_name = '%s' and package_name='%s'", ACCOUNT_TABLE, user_name, package_name); + hstmt = _account_prepare_query(query); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + while (rc == SQLITE_ROW) { + _account_convert_column_to_account(hstmt, old_account); + rc = _account_query_step(hstmt); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_CATCH_ERROR((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + // get capability + error_code = account_query_capability_by_account_id(_account_get_capability_text_cb, old_account->id, (void*)old_account); + ACCOUNT_CATCH_ERROR((error_code == ACCOUNT_ERROR_NONE), {}, error_code, ("account_query_capability_by_account_id error")); + + // get custom text + error_code = _account_query_custom_by_account_id(_account_get_custom_text_cb, old_account->id, (void*)old_account); + ACCOUNT_CATCH_ERROR((error_code == ACCOUNT_ERROR_NONE), {}, error_code, ("_account_query_custom_by_account_id error")); + + // compare + new_account->id = old_account->id; + + //user name + if(!new_account->user_name) { + if(old_account->user_name) + new_account->user_name = _account_get_text(old_account->user_name); + } + + // display name + if(!new_account->display_name) { + if(old_account->display_name) + new_account->display_name = _account_get_text(old_account->display_name); + } + + // email address + if(!new_account->email_address) { + if(old_account->email_address) + new_account->email_address = _account_get_text(old_account->email_address); + } + + // domain name + if(!new_account->domain_name) { + if(old_account->domain_name) + new_account->domain_name = _account_get_text(old_account->domain_name); + } + + // icon path + if(!new_account->icon_path) { + if(old_account->icon_path) + new_account->icon_path = _account_get_text(old_account->icon_path); + } + + // source + if(!new_account->source) { + if(old_account->source) + new_account->source = _account_get_text(old_account->source); + } + + _ACCOUNT_FREE(new_account->package_name); + new_account->package_name = _account_get_text(old_account->package_name); + + // access token + if(!new_account->access_token) { + if(old_account->access_token) + new_account->access_token = _account_get_text(old_account->access_token); + } + + // user text + int i; + for(i=0;i<USER_TXT_CNT;i++) { + if(!new_account->user_data_txt[i]) { + if(old_account->user_data_txt[i]) + new_account->user_data_txt[i] = _account_get_text(old_account->user_data_txt[i]); + } + } + + // auth type + if(new_account->auth_type == ACCOUNT_AUTH_TYPE_INVALID) { + new_account->auth_type = old_account->auth_type; + } + + //secret + if(new_account->secret== ACCOUNT_SECRECY_INVALID) { + new_account->secret = old_account->secret; + } + + // sync support + if(new_account->sync_support == ACCOUNT_SYNC_INVALID) { + new_account->sync_support = old_account->sync_support; + } + + // user int + for(i=0;i<USER_INT_CNT;i++) { + if(new_account->user_data_int[i] == 0) { + new_account->user_data_int[i] = old_account->user_data_int[i]; + } + } + + // capability + + // user custom table + + + + CATCH: + if (old_account) { + _account_free_account_items(old_account); + _ACCOUNT_FREE(old_account); + } + + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + return ACCOUNT_ERROR_NONE; +} + + + +static int _account_update_account_by_user_name(account_s *account, const char *user_name, const char *package_name) +{ + int rc = 0, binding_count = 0, count = 0; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + + ACCOUNT_RETURN_VAL((user_name != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("user_name is NULL.\n")); + ACCOUNT_RETURN_VAL((package_name!= NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("package_name is NULL.\n")); + + char* current_appid = NULL; + char* verified_appid = NULL; + + current_appid = _account_get_current_appid(); + error_code = _account_check_account_type_with_appid_group(current_appid, &verified_appid); + + _ACCOUNT_FREE(current_appid); + _ACCOUNT_FREE(verified_appid); + + if(error_code != ACCOUNT_ERROR_NONE){ + ACCOUNT_ERROR("No permission to update\n"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + _account_compare_old_record_by_user_name(account, user_name, package_name); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (!account->package_name) { + ACCOUNT_ERROR("Package name is mandetory field, it can not be NULL!!!!\n"); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!account->user_name && !account->display_name && !account->email_address) { + ACCOUNT_ERROR("One field should be set among user name, display name, email address\n"); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE user_name='%s' and package_name='%s'" + , ACCOUNT_TABLE, user_name, package_name); + + count = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (count <= 0) { + ACCOUNT_SLOGI("_account_update_account_by_user_name : The account not exist!, count = %d, user_name=%s, package_name=%s\n", + count, user_name, package_name); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "UPDATE %s SET user_name=?, email_address =?, display_name =?, " + "icon_path =?, source =?, package_name =? , access_token =?, domain_name =?, auth_type =?, secret =?, sync_support =?," + "txt_custom0=?, txt_custom1=?, txt_custom2=?, txt_custom3=?, txt_custom4=?, " + "int_custom0=?, int_custom1=?, int_custom2=?, int_custom3=?, int_custom4=? WHERE user_name=? and package_name=? ", ACCOUNT_TABLE); + + hstmt = _account_prepare_query(query); + if( _account_db_err_code() == SQLITE_PERM ){ + _account_end_transaction(FALSE); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_svc_query_prepare() failed(%s).\n", _account_db_err_msg())); + + binding_count = _account_convert_account_to_sql(account, hstmt, query); + + _account_query_bind_text(hstmt, binding_count++, user_name); + _account_query_bind_text(hstmt, binding_count++, package_name); + rc = _account_query_step(hstmt); + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + } + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + /*update capability*/ + error_code = _account_update_capability_by_user_name(account, user_name, package_name); + + /* update custom */ + error_code = _account_update_custom(account, account->id); + + return error_code; +} + +ACCOUNT_API int account_insert_to_db(account_h account, int *account_id) +{ + int error_code = ACCOUNT_ERROR_NONE; + int ret_transaction = 0; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + ACCOUNT_RETURN_VAL((account_id != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT ID POINTER IS NULL")); + + account_s *data = (account_s*)account; + ACCOUNT_SLOGD("(%s)-(%d) account_insert_to_db: begin_transaction.\n", __FUNCTION__, __LINE__); + + pthread_mutex_lock(&account_mutex); + + /* transaction control required*/ + ret_transaction = _account_begin_transaction(); + + if(_account_db_err_code() == SQLITE_PERM){ + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (ret_transaction == ACCOUNT_ERROR_DATABASE_BUSY) { + ACCOUNT_ERROR("account insert:_account_begin_transaction fail %d\n", ret_transaction); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_DATABASE_BUSY; + }else if (ret_transaction != ACCOUNT_ERROR_NONE) { + ACCOUNT_ERROR("account insert:_account_begin_transaction fail %d\n", ret_transaction); + pthread_mutex_unlock(&account_mutex); + return ret_transaction; + } + + if (_account_check_duplicated(data)) { + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_DEBUG("Duplicated, rollback insert query(%x)!!!!\n", ret_transaction); + *account_id = -1; + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_DUPLICATED; + } else { + *account_id = _account_get_next_sequence(ACCOUNT_TABLE); + + char* appid = NULL; + appid = _account_get_current_appid(); + + if(!appid){ + // API caller cannot be recognized + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("App id is not registered in account type DB, transaction ret (%x)!!!!\n", ret_transaction); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_NOT_REGISTERED_PROVIDER; + } + + char* verified_appid = NULL; + error_code = _account_check_account_type_with_appid_group(appid, &verified_appid); + if(error_code != ACCOUNT_ERROR_NONE){ + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("App id is not registered in account type DB, transaction ret (%x)!!!!\n", ret_transaction); + _ACCOUNT_FREE(verified_appid); + _ACCOUNT_FREE(appid); + pthread_mutex_unlock(&account_mutex); + return error_code; + } + + _ACCOUNT_FREE(appid); + + if(verified_appid){ + if(!_account_check_add_more_account(verified_appid)) { + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("No more account cannot be added, transaction ret (%x)!!!!\n", ret_transaction); + pthread_mutex_unlock(&account_mutex); + _ACCOUNT_FREE(verified_appid); + return ACCOUNT_ERROR_NOT_ALLOW_MULTIPLE; + } + + _ACCOUNT_FREE(data->package_name); + data->package_name = _account_get_text(verified_appid); + _ACCOUNT_FREE(verified_appid); + if(!data->package_name) { + ACCOUNT_ERROR("Memory Allocation Failed"); + return ACCOUNT_ERROR_OUT_OF_MEMORY; + } + } + +#ifdef SAMSUNG_ACCOUNT_MANAGER + if(!strcmp(data->package_name,SAMSUNGACCOUNT_PKG_NAME)){ + //temporary feature for samsung account domain + int ret = -1; + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) { + ACCOUNT_DEBUG("set_domain error(%x)!!!!\n", ret); + } + } +#endif + + if(!_account_check_add_more_account(data->package_name)) { + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("No more account cannot be added, transaction ret (%x)!!!!\n", ret_transaction); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_NOT_ALLOW_MULTIPLE; + } + + error_code = _account_execute_insert_query(data); + + if (error_code != ACCOUNT_ERROR_NONE) { + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("INSERT account fail, rollback insert query(%x)!!!!\n", ret_transaction); + *account_id = -1; + pthread_mutex_unlock(&account_mutex); + return error_code; + } + } + + error_code = _account_insert_capability(data, *account_id); + if (error_code != ACCOUNT_ERROR_NONE) { + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("INSERT capability fail, rollback insert capability query(%x)!!!!\n", ret_transaction); + *account_id = -1; + pthread_mutex_unlock(&account_mutex); + return error_code; + } + + error_code = _account_insert_custom(data, *account_id); + if (error_code != ACCOUNT_ERROR_NONE) { + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("INSERT custom fail, rollback insert capability query(%x)!!!!\n", ret_transaction); + *account_id = -1; + pthread_mutex_unlock(&account_mutex); + return error_code; + } + + pthread_mutex_unlock(&account_mutex); + _account_end_transaction(TRUE); + ACCOUNT_SLOGD("(%s)-(%d) account _end_transaction.\n", __FUNCTION__, __LINE__); + + char buf[64]={0,}; + ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", ACCOUNT_NOTI_NAME_INSERT, *account_id); + _account_insert_delete_update_notification_send(buf); + ACCOUNT_SLOGD("(%s)-(%d) account _notification_send.\n", __FUNCTION__, __LINE__); + + return ACCOUNT_ERROR_NONE; + +} + +ACCOUNT_API int account_create(account_h *account) +{ + if (!account) { + ACCOUNT_SLOGE("(%s)-(%d) account is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)malloc(sizeof(account_s)); + + if (data == NULL) { + ACCOUNT_FATAL("Memory Allocation Failed"); + return ACCOUNT_ERROR_OUT_OF_MEMORY; + } + ACCOUNT_MEMSET(data, 0, sizeof(account_s)); + + /*Setting account as visible by default*/ + data->secret = ACCOUNT_SECRECY_VISIBLE; + + /*Setting account as not supporting sync by default*/ + data->sync_support = ACCOUNT_SYNC_NOT_SUPPORT; + + *account = (account_h)data; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_user_name(account_h account, const char *user_name) +{ + if (!account) { + ACCOUNT_SLOGE("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!user_name) { + ACCOUNT_SLOGE("(%s)-(%d) user_name is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + _ACCOUNT_FREE(data->user_name); + data->user_name = _account_get_text(user_name); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_display_name(account_h account, const char *display_name) +{ + if (!account) { + ACCOUNT_SLOGE("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!display_name) { + ACCOUNT_SLOGE("(%s)-(%d) display_name is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + _ACCOUNT_FREE(data->display_name); + data->display_name = _account_get_text(display_name); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_email_address(account_h account, const char *email_address) +{ + if (!account) { + ACCOUNT_SLOGE("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!email_address) { + ACCOUNT_SLOGE("(%s)-(%d) email_address is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + _ACCOUNT_FREE(data->email_address); + data->email_address = _account_get_text(email_address); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_icon_path(account_h account, const char *icon_path) +{ + if (!account) { + ACCOUNT_SLOGE("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!icon_path) { + ACCOUNT_SLOGE("(%s)-(%d) icon_path is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + _ACCOUNT_FREE(data->icon_path); + data->icon_path = _account_get_text(icon_path); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_source(account_h account, const char *source) +{ + if (!account) { + ACCOUNT_SLOGE("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!source) { + ACCOUNT_SLOGE("(%s)-(%d) source is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + account_s *data = (account_s*)account; + + _ACCOUNT_FREE(data->source); + data->source = _account_get_text(source); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_package_name(account_h account, const char *package_name) +{ + if (!account) { + ACCOUNT_SLOGE("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!package_name) { + ACCOUNT_SLOGE("(%s)-(%d) package_name is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + _ACCOUNT_FREE(data->package_name); + data->package_name = _account_get_text(package_name); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_domain_name(account_h account, const char *domain_name) +{ + if (!account) { + ACCOUNT_SLOGE("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!domain_name) { + ACCOUNT_SLOGE("(%s)-(%d) domain_name is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + account_s *data = (account_s*)account; + + _ACCOUNT_FREE(data->domain_name); + data->domain_name = _account_get_text(domain_name); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_access_token(account_h account, const char *access_token) +{ + if (!account) { + ACCOUNT_SLOGE("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!access_token) { + ACCOUNT_SLOGE("(%s)-(%d) access_token is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + _ACCOUNT_FREE(data->access_token); + data->access_token = _account_get_text(access_token); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_user_text(account_h account, int idx, const char *user_txt) +{ + if (!account) { + ACCOUNT_SLOGE("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!user_txt) { + ACCOUNT_SLOGE("(%s)-(%d) user_txt is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + if (idx >= USER_TXT_CNT || idx < 0) { + ACCOUNT_SLOGE("(%s)-(%d) index rage should be between 0-4.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + _ACCOUNT_FREE(data->user_data_txt[idx]); + data->user_data_txt[idx] = _account_get_text(user_txt); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_custom(account_h account, const char* key, const char* value) +{ + if (!account) { + ACCOUNT_SLOGE("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!key) { + ACCOUNT_SLOGE("(%s)-(%d) key is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!value) { + ACCOUNT_SLOGE("(%s)-(%d) value is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + GSList *iter; + bool b_is_new = TRUE; + + for (iter = data->custom_list; iter != NULL; iter = g_slist_next(iter)) { + + account_custom_s* custom_data = NULL; + custom_data = (account_custom_s*)iter->data; + ACCOUNT_SLOGD( "account_custom_s->key = %s, account_custom_s->value = %s \n", custom_data->key, custom_data->value); + + if(!strcmp(custom_data->key, key)) { + _ACCOUNT_FREE(custom_data->value); + custom_data->value = _account_get_text(value); + b_is_new = FALSE; + } + } + + if(b_is_new) { + account_custom_s* custom_data = (account_custom_s*)malloc(sizeof(account_custom_s)); + + if (custom_data == NULL) { + return ACCOUNT_ERROR_OUT_OF_MEMORY; + } + ACCOUNT_MEMSET(custom_data, 0, sizeof(account_custom_s)); + custom_data->account_id = data->id; + custom_data->app_id = _account_get_text(data->package_name); + custom_data->key = _account_get_text(key); + custom_data->value = _account_get_text(value); + data->custom_list = g_slist_append(data->custom_list, (gpointer)custom_data); + } + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_auth_type(account_h account, const account_auth_type_e auth_type) +{ + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__)); + + if ( ((int)auth_type < 0) || (auth_type > ACCOUNT_AUTH_TYPE_MAX) ) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + data->auth_type = (int)auth_type; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_secret(account_h account, const account_secrecy_state_e secret) +{ + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__)); + + if ( ((int)secret < 0) || (secret > ACCOUNT_SECRECY_MAX)) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + data->secret = (int)secret; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_sync_support(account_h account, const account_sync_state_e sync_support) +{ + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__)); + + if ( ((int)sync_support < 0) || (sync_support > ACCOUNT_SYNC_MAX)) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + data->sync_support= (int)sync_support; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_user_int(account_h account, int idx, const int user_int) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (idx >= USER_INT_CNT ||idx < 0) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + data->user_data_int[idx] = user_int; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_set_capability(account_h account, const char* capability_type, account_capability_state_e capability_value) +{ + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("account handle is null")); + ACCOUNT_RETURN_VAL((capability_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("capability_type is null")); + + if ((capability_value != ACCOUNT_CAPABILITY_DISABLED) && (capability_value != ACCOUNT_CAPABILITY_ENABLED)) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + GSList *iter = NULL; + bool b_is_new = TRUE; + + for(iter = data->capablity_list; iter != NULL; iter = g_slist_next(iter)) { + account_capability_s *cap_data = NULL; + cap_data = (account_capability_s*)iter->data; + + if(!strcmp(cap_data->type, capability_type)) { + cap_data->value = capability_value; + b_is_new = FALSE; + break; + } + } + + if(b_is_new) { + account_capability_s* cap_data = (account_capability_s*)malloc(sizeof(account_capability_s)); + + if (cap_data == NULL) + return ACCOUNT_ERROR_OUT_OF_MEMORY; + ACCOUNT_MEMSET(cap_data, 0, sizeof(account_capability_s)); + + cap_data->type = _account_get_text(capability_type); + cap_data->value = capability_value; + data->capablity_list = g_slist_append(data->capablity_list, (gpointer)cap_data); + } + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_user_name(account_h account, char **user_name) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!user_name) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + (*user_name) = NULL; + *user_name = _account_get_text(data->user_name); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_display_name(account_h account, char **display_name) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!display_name) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + (*display_name) = NULL; + + *display_name = _account_get_text(data->display_name); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_email_address(account_h account,char **email_address) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!email_address) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + (*email_address) = NULL; + + *email_address = _account_get_text(data->email_address); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_icon_path(account_h account, char **icon_path) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!icon_path) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + (*icon_path) = NULL; + + *icon_path = _account_get_text(data->icon_path); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_source(account_h account, char **source) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!source) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + (*source) = NULL; + + *source = _account_get_text(data->source); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_package_name(account_h account, char **package_name) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!package_name) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + (*package_name) = NULL; + + *package_name = _account_get_text(data->package_name); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_domain_name(account_h account, char **domain_name) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!domain_name) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + (*domain_name) = NULL; + + *domain_name = _account_get_text(data->domain_name); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_access_token(account_h account, char **access_token) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!access_token) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + (*access_token) = NULL; + + *access_token = _account_get_text(data->access_token); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_user_text(account_h account, int user_text_index, char **text) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!text) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + ACCOUNT_RETURN_VAL((user_text_index >=0 && user_text_index < USER_TXT_CNT ), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("INVALID USER TEXT INDEX")); + + account_s *data = (account_s*)account; + + (*text) = NULL; + + *text = _account_get_text(data->user_data_txt[user_text_index]); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_auth_type(account_h account, account_auth_type_e *auth_type) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + if (!auth_type) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s* data = (account_s*)account; + + *auth_type = data->auth_type; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_secret(account_h account, account_secrecy_state_e *secret) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + if (!secret) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s* data = (account_s*)account; + + *secret = data->secret; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_sync_support(account_h account, account_sync_state_e *sync_support) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + if (!sync_support) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s* data = (account_s*)account; + + *sync_support = data->sync_support; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_account_id(account_h account, int *account_id) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + if (!account_id) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + *account_id = data->id; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_user_int(account_h account, int user_int_index, int *integer) +{ + if (!account) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + ACCOUNT_RETURN_VAL((user_int_index >=0 && user_int_index < USER_TXT_CNT ), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("INVALID USER TEXT INDEX")); + + if (!integer) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_s *data = (account_s*)account; + + *integer = data->user_data_int[user_int_index]; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_capability(account_h account, const char* capability_type, account_capability_state_e* capability_value) +{ + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + ACCOUNT_RETURN_VAL((capability_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("capability_type is NULL")); + ACCOUNT_RETURN_VAL((capability_value != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("capability_value is NULL")); + + GSList *iter; + account_s *data = (account_s*)account; + + for (iter = data->capablity_list; iter != NULL; iter = g_slist_next(iter)) { + account_capability_s *cap_data = NULL; + + cap_data = (account_capability_s*)iter->data; + + if(!strcmp(capability_type, cap_data->type)) { + *capability_value = cap_data->value; + return ACCOUNT_ERROR_NONE; + } + } + + return ACCOUNT_ERROR_RECORD_NOT_FOUND; +} + +ACCOUNT_API int account_get_capability_all(account_h account, capability_cb callback, void *user_data) +{ + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION")); + + GSList *iter; + account_s *data = (account_s*)account; + + for (iter = data->capablity_list; iter != NULL; iter = g_slist_next(iter)) { + account_capability_s *cap_data = NULL; + + cap_data = (account_capability_s*)iter->data; + + if(callback(cap_data->type, cap_data->value, user_data)!=TRUE){ + return ACCOUNT_ERROR_NONE; + } + } + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_get_custom(account_h account, const char* key, char** value) +{ + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + ACCOUNT_RETURN_VAL((key != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("NO KEY TO REQUEST")); + ACCOUNT_RETURN_VAL((value != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("VALUE POINTER IS NULL")); + + GSList *iter; + account_s *data = (account_s*)account; + + for (iter = data->custom_list; iter != NULL; iter = g_slist_next(iter)) { + account_custom_s *custom_data = NULL; + + custom_data = (account_custom_s*)iter->data; + + if(!strcmp(key, custom_data->key)) { + (*value) = NULL; + *value = _account_get_text(custom_data->value); + return ACCOUNT_ERROR_NONE; + } + } + + return ACCOUNT_ERROR_RECORD_NOT_FOUND; +} + +ACCOUNT_API int account_get_custom_all(account_h account, account_custom_cb callback, void* user_data) +{ + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION")); + + GSList *iter; + account_s *data = (account_s*)account; + + for (iter = data->custom_list; iter != NULL; iter = g_slist_next(iter)) { + bool cb_ret = FALSE; + account_custom_s *custom_data = NULL; + + custom_data = (account_custom_s*)iter->data; + + cb_ret = callback(custom_data->key, custom_data->value, user_data); + if(!cb_ret) { + break; + } + } + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_query_capability_by_account_id(capability_cb callback, int account_id, void *user_data ) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((account_id > 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INDEX IS LESS THAN 0")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE account_id = %d", CAPABILITY_TABLE, account_id); + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + account_capability_s* capability_record = NULL; + + while (rc == SQLITE_ROW) { + bool cb_ret = FALSE; + capability_record = (account_capability_s*) malloc(sizeof(account_capability_s)); + + if (capability_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + + ACCOUNT_MEMSET(capability_record, 0x00, sizeof(account_capability_s)); + + _account_convert_column_to_capability(hstmt, capability_record); + + cb_ret = callback(capability_record->type, capability_record->value, user_data); + + _account_free_capability_items(capability_record); + _ACCOUNT_FREE(capability_record); + + ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n")); + + rc = _account_query_step(hstmt); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +static int _account_compare_old_record(account_s *new_account, int account_id) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + account_s *old_account = NULL; + + ACCOUNT_RETURN_VAL((account_id > 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INDEX IS LESS THAN 0")); + ACCOUNT_RETURN_VAL((new_account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + old_account = (account_s*)calloc(1, sizeof(account_s)); + ACCOUNT_RETURN_VAL((old_account != NULL), {}, ACCOUNT_ERROR_OUT_OF_MEMORY,("Memory Allocation Failed")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id = %d", ACCOUNT_TABLE, account_id); + hstmt = _account_prepare_query(query); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + while (rc == SQLITE_ROW) { + _account_convert_column_to_account(hstmt, old_account); + rc = _account_query_step(hstmt); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_CATCH_ERROR((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + // get capability + error_code = account_query_capability_by_account_id(_account_get_capability_text_cb, old_account->id, (void*)old_account); + ACCOUNT_CATCH_ERROR((error_code == ACCOUNT_ERROR_NONE), {}, error_code, ("account_query_capability_by_account_id error")); + + // get custom text + error_code = _account_query_custom_by_account_id(_account_get_custom_text_cb, old_account->id, (void*)old_account); + ACCOUNT_CATCH_ERROR((error_code == ACCOUNT_ERROR_NONE), {}, error_code, ("_account_query_custom_by_account_id error")); + + // compare + + new_account->id = old_account->id; + + //user name + if(!new_account->user_name) { + if(old_account->user_name) + new_account->user_name = _account_get_text(old_account->user_name); + } + + // display name + if(!new_account->display_name) { + if(old_account->display_name) + new_account->display_name = _account_get_text(old_account->display_name); + } + + // email address + if(!new_account->email_address) { + if(old_account->email_address) + new_account->email_address = _account_get_text(old_account->email_address); + } + + // domain name + if(!new_account->domain_name) { + if(old_account->domain_name) + new_account->domain_name = _account_get_text(old_account->domain_name); + } + + // icon path + if(!new_account->icon_path) { + if(old_account->icon_path) + new_account->icon_path = _account_get_text(old_account->icon_path); + } + + // source + if(!new_account->source) { + if(old_account->source) + new_account->source = _account_get_text(old_account->source); + } + + _ACCOUNT_FREE(new_account->package_name); + new_account->package_name = _account_get_text(old_account->package_name); + + // access token + if(!new_account->access_token) { + if(old_account->access_token) + new_account->access_token = _account_get_text(old_account->access_token); + } + + // user text + int i; + for(i=0;i<USER_TXT_CNT;i++) { + if(!new_account->user_data_txt[i]) { + if(old_account->user_data_txt[i]) + new_account->user_data_txt[i] = _account_get_text(old_account->user_data_txt[i]); + } + } + + // auth type + if(new_account->auth_type == ACCOUNT_AUTH_TYPE_INVALID) { + new_account->auth_type = old_account->auth_type; + } + + //secret + if(new_account->secret== ACCOUNT_SECRECY_INVALID) { + new_account->secret = old_account->secret; + } + + // sync support + if(new_account->sync_support == ACCOUNT_SYNC_INVALID) { + new_account->sync_support = old_account->sync_support; + } + + // user int + for(i=0;i<USER_INT_CNT;i++) { + if(new_account->user_data_int[i] == 0) { + new_account->user_data_int[i] = old_account->user_data_int[i]; + } + } + + // capability + + // user custom table + + + + CATCH: + if (old_account) { + _account_free_account_items(old_account); + _ACCOUNT_FREE(old_account); + } + + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + return ACCOUNT_ERROR_NONE; +} + +static int _account_get_package_name_from_account_id(int account_id, char **package_name) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + account_s *old_account = NULL; + + ACCOUNT_RETURN_VAL((account_id > 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INDEX IS LESS THAN 0")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + old_account = (account_s*)calloc(1, sizeof(account_s)); + ACCOUNT_RETURN_VAL((old_account != NULL), {}, ACCOUNT_ERROR_OUT_OF_MEMORY,("Memory Allocation Failed")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id = %d", ACCOUNT_TABLE, account_id); + hstmt = _account_prepare_query(query); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + while (rc == SQLITE_ROW) { + _account_convert_column_to_account(hstmt, old_account); + rc = _account_query_step(hstmt); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_CATCH_ERROR((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + // get package name. + *package_name = _account_get_text(old_account->package_name); + + + CATCH: + if (old_account) { + _account_free_account_items(old_account); + _ACCOUNT_FREE(old_account); + } + + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + return error_code; + +} + +static int _account_update_account(account_s *account, int account_id) +{ + int rc = 0, binding_count =0; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int error_code = ACCOUNT_ERROR_NONE, count=0, ret_transaction = 0; + account_stmt hstmt = NULL; + + if (!account->package_name) { + ACCOUNT_ERROR("Package name is mandetory field, it can not be NULL!!!!\n"); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + /* Check permission of requested appid */ + char* current_appid = NULL; + char *package_name = NULL; + + current_appid = _account_get_current_appid(); + error_code = _account_get_package_name_from_account_id(account_id, &package_name); + + if(error_code != ACCOUNT_ERROR_NONE || package_name == NULL){ + ACCOUNT_ERROR("No package name with account_id\n"); + _ACCOUNT_FREE(current_appid); + _ACCOUNT_FREE(package_name); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + error_code = _account_check_appid_group_with_package_name(current_appid, package_name); + ACCOUNT_DEBUG( "UPDATE:account_id[%d],current_appid[%s]package_name[%s]", account_id, current_appid, package_name); // TODO: remove the log later. + + _ACCOUNT_FREE(current_appid); + _ACCOUNT_FREE(package_name); + + if(error_code != ACCOUNT_ERROR_NONE){ + ACCOUNT_ERROR("No permission to update\n"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + _account_compare_old_record(account, account_id); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } else if( _account_db_err_code() == SQLITE_BUSY ){ + ACCOUNT_ERROR( "database busy(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_DATABASE_BUSY; + } + + if (!account->user_name && !account->display_name && !account->email_address) { + ACCOUNT_ERROR("One field should be set among user name, display name, email address\n"); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE _id = %d ", ACCOUNT_TABLE, account_id); + + count = _account_get_record_count(query); + if (count <= 0) { + ACCOUNT_DEBUG(" Account record not found, count = %d\n", count); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + /* transaction control required*/ + ret_transaction = _account_begin_transaction(); + if( ret_transaction == ACCOUNT_ERROR_DATABASE_BUSY ){ + ACCOUNT_ERROR( "database busy(%s)", _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_DATABASE_BUSY; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "UPDATE %s SET user_name=?, email_address =?, display_name =?, " + "icon_path =?, source =?, package_name =? , access_token =?, domain_name =?, auth_type =?, secret =?, sync_support =?," + "txt_custom0=?, txt_custom1=?, txt_custom2=?, txt_custom3=?, txt_custom4=?, " + "int_custom0=?, int_custom1=?, int_custom2=?, int_custom3=?, int_custom4=? WHERE _id=? ", ACCOUNT_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_svc_query_prepare() failed(%s)(%x).\n", _account_db_err_msg(), _account_end_transaction(FALSE))); + + binding_count = _account_convert_account_to_sql(account, hstmt, query); + _account_query_bind_int(hstmt, binding_count++, account_id); + + rc = _account_query_step(hstmt); + if (rc != SQLITE_DONE) { + ACCOUNT_SLOGE( "account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + /*update capability*/ + error_code = _account_update_capability(account, account_id); + if(error_code != ACCOUNT_ERROR_NONE && error_code!= ACCOUNT_ERROR_RECORD_NOT_FOUND){ + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("update capability Failed, trying to roll back(%x) !!!\n", ret_transaction); + return error_code; + } + + /* update custom */ + error_code = _account_update_custom(account, account_id); + if(error_code != ACCOUNT_ERROR_NONE && error_code!= ACCOUNT_ERROR_RECORD_NOT_FOUND){ + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("update capability Failed, trying to roll back(%x) !!!\n", ret_transaction); + return error_code; + } + + ret_transaction = _account_end_transaction(TRUE); + + return error_code; +} + + +static int _account_update_account_ex(account_s *account, int account_id) +{ + int rc = 0, binding_count =0; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int error_code = ACCOUNT_ERROR_NONE, count=0, ret_transaction = 0; + account_stmt hstmt = NULL; + + if (!account->package_name) { + ACCOUNT_ERROR("Package name is mandetory field, it can not be NULL!!!!\n"); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + _account_compare_old_record(account, account_id); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (!account->user_name && !account->display_name && !account->email_address) { + ACCOUNT_ERROR("One field should be set among user name, display name, email address\n"); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE _id = %d ", ACCOUNT_TABLE, account_id); + + count = _account_get_record_count(query); + if (count <= 0) { + ACCOUNT_DEBUG(" Account record not found, count = %d\n", count); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + /* transaction control required*/ + ret_transaction = _account_begin_transaction(); + if( ret_transaction == ACCOUNT_ERROR_DATABASE_BUSY ){ + ACCOUNT_ERROR( "database busy(%s)", _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_DATABASE_BUSY; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "UPDATE %s SET user_name=?, email_address =?, display_name =?, " + "icon_path =?, source =?, package_name =? , access_token =?, domain_name =?, auth_type =?, secret =?, sync_support =?," + "txt_custom0=?, txt_custom1=?, txt_custom2=?, txt_custom3=?, txt_custom4=?, " + "int_custom0=?, int_custom1=?, int_custom2=?, int_custom3=?, int_custom4=? WHERE _id=? ", ACCOUNT_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_svc_query_prepare() failed(%s)(%x).\n", _account_db_err_msg(), _account_end_transaction(FALSE))); + + binding_count = _account_convert_account_to_sql(account, hstmt, query); + _account_query_bind_int(hstmt, binding_count++, account_id); + + rc = _account_query_step(hstmt); + if (rc != SQLITE_DONE) { + ACCOUNT_SLOGE( "account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + /*update capability*/ + error_code = _account_update_capability(account, account_id); + if(error_code != ACCOUNT_ERROR_NONE && error_code!= ACCOUNT_ERROR_RECORD_NOT_FOUND){ + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("update capability Failed, trying to roll back(%x) !!!\n", ret_transaction); + return error_code; + } + + /* update custom */ + error_code = _account_update_custom(account, account_id); + if(error_code != ACCOUNT_ERROR_NONE && error_code!= ACCOUNT_ERROR_RECORD_NOT_FOUND){ + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("update capability Failed, trying to roll back(%x) !!!\n", ret_transaction); + return error_code; + } + + ret_transaction = _account_end_transaction(TRUE); + + return error_code; +} + + +ACCOUNT_API int account_update_to_db_by_id(const account_h account, int account_id) +{ + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("DATA IS NULL")); + ACCOUNT_RETURN_VAL((account_id > 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Account id is not valid")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + int error_code = ACCOUNT_ERROR_NONE; + account_s* data = (account_s*)account; + + pthread_mutex_lock(&account_mutex); + + error_code = _account_update_account(data, account_id); + + if(error_code != ACCOUNT_ERROR_NONE) { + pthread_mutex_unlock(&account_mutex); + return error_code; + } + + pthread_mutex_unlock(&account_mutex); + + char buf[64]={0,}; + ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", ACCOUNT_NOTI_NAME_UPDATE, account_id); + _account_insert_delete_update_notification_send(buf); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_update_to_db_by_id_ex(const account_h account, int account_id) +{ + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("DATA IS NULL")); + ACCOUNT_RETURN_VAL((account_id > 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Account id is not valid")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + int error_code = ACCOUNT_ERROR_NONE; + account_s* data = (account_s*)account; + + pthread_mutex_lock(&account_mutex); + + error_code = _account_update_account_ex(data, account_id); + + if(error_code != ACCOUNT_ERROR_NONE) { + pthread_mutex_unlock(&account_mutex); + return error_code; + } + + pthread_mutex_unlock(&account_mutex); + + char buf[64]={0,}; + ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", ACCOUNT_NOTI_NAME_UPDATE, account_id); + _account_insert_delete_update_notification_send(buf); + + return ACCOUNT_ERROR_NONE; +} + + +ACCOUNT_API int account_update_to_db_by_user_name(account_h account, const char *user_name, const char *package_name) +{ + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("DATA IS NULL")); + ACCOUNT_RETURN_VAL((user_name != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("USER NAME IS NULL")); + ACCOUNT_RETURN_VAL((package_name != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("PACKAGE NAME IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + int error_code = ACCOUNT_ERROR_NONE; + account_s *data = (account_s*)account; + + pthread_mutex_lock(&account_mutex); + + error_code = _account_update_account_by_user_name(data, user_name, package_name); + + pthread_mutex_unlock(&account_mutex); + + char buf[64]={0,}; + ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", ACCOUNT_NOTI_NAME_UPDATE, data->id); + _account_insert_delete_update_notification_send(buf); + + return error_code; +} + +ACCOUNT_API int account_foreach_account_from_db(account_cb callback, void *user_data) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + GList *account_list = NULL; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INFO IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s ", ACCOUNT_TABLE); + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + rc = _account_query_step(hstmt); + + account_s *account_record = NULL; + + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + int k=0; + while(rc == SQLITE_ROW) { + account_record = (account_s*) malloc(sizeof(account_s)); + + if (account_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + + ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s)); + _account_convert_column_to_account(hstmt, account_record); + account_list = g_list_append(account_list, account_record); + rc = _account_query_step(hstmt); + k++; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {_account_glist_free(account_list);}, rc, ("finalize error")); + hstmt = NULL; + + GList* iter; + k = 0; + for (iter = account_list; iter != NULL; iter = g_list_next(iter)) { + account_s *account = NULL; + account = (account_s*)iter->data; + account_query_capability_by_account_id(_account_get_capability_text_cb, account->id, (void*)account); + _account_query_custom_by_account_id(_account_get_custom_text_cb, account->id, (void*)account); + callback((account_h)account, user_data); + k++; + } + + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + if (account_list) { + _account_glist_free(account_list); + account_list = NULL; + } + + return error_code; +} + +ACCOUNT_API int account_update_sync_status_by_id(int account_db_id, const account_sync_state_e sync_status) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + int count =1; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((account_db_id > 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INDEX IS LESS THAN 0")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + if ( ((int)sync_status < 0) || (sync_status > ACCOUNT_SYNC_MAX) ) { + ACCOUNT_SLOGE("(%s)-(%d) sync_status is less than 0 or more than enum max.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + pthread_mutex_lock(&account_mutex); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_db_id); + + rc = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (rc <= 0) { + ACCOUNT_SLOGE( "account_update_sync_status_by_id : related account item is not existed rc=%d , %s", rc, _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "UPDATE %s SET sync_support=? WHERE _id = %d", ACCOUNT_TABLE, account_db_id); + hstmt = _account_prepare_query(query); + + _account_query_bind_int(hstmt, count, (int)sync_status); + + rc = _account_query_step(hstmt); + + if( _account_db_err_code() == SQLITE_PERM ){ + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_DB_FAILED, + ("account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg())); + + rc = _account_query_finalize(hstmt); + if (rc != ACCOUNT_ERROR_NONE) { + ACCOUNT_ERROR("_account_query_finalize error"); + pthread_mutex_unlock(&account_mutex); + return rc; + } + char buf[64]={0,}; + ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", ACCOUNT_NOTI_NAME_SYNC_UPDATE, account_db_id); + _account_insert_delete_update_notification_send(buf); + + hstmt = NULL; + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + pthread_mutex_unlock(&account_mutex); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +ACCOUNT_API int account_query_account_by_account_id(int account_db_id, account_h *account) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((account_db_id > 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INDEX IS LESS THAN 0")); + ACCOUNT_RETURN_VAL((*account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id = %d", ACCOUNT_TABLE, account_db_id); + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + account_s *account_record = (account_s *)(*account); + + while (rc == SQLITE_ROW) { + _account_convert_column_to_account(hstmt, account_record); + rc = _account_query_step(hstmt); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + + account_query_capability_by_account_id(_account_get_capability_text_cb, account_record->id, (void*)account_record); + _account_query_custom_by_account_id(_account_get_custom_text_cb, account_record->id, (void*)account_record); + + hstmt = NULL; + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +ACCOUNT_API int account_query_account_by_user_name(account_cb callback, const char *user_name, void *user_data) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((user_name != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("USER NAME IS NULL")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("CALL BACK IS NULL")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE user_name = ?", ACCOUNT_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + int binding_count = 1; + _account_query_bind_text(hstmt, binding_count++, user_name); + + rc = _account_query_step(hstmt); + + account_s *account_head = NULL; + + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + int tmp = 0; + + account_head = (account_s*) malloc(sizeof(account_s)); + if (account_head == NULL) { + ACCOUNT_FATAL("malloc Failed"); + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + return ACCOUNT_ERROR_OUT_OF_MEMORY; + } + ACCOUNT_MEMSET(account_head, 0x00, sizeof(account_s)); + + while (rc == SQLITE_ROW) { + account_s* account_record = NULL; + + account_record = (account_s*) malloc(sizeof(account_s)); + + if (account_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s)); + + _account_convert_column_to_account(hstmt, account_record); + + account_head->account_list = g_list_append(account_head->account_list, account_record); + + rc = _account_query_step(hstmt); + tmp++; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_CATCH_ERROR((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + GList *iter; + + + tmp = g_list_length(account_head->account_list); + + for (iter = account_head->account_list; iter != NULL; iter = g_list_next(iter)) { + account_h account; + account = (account_h)iter->data; + + account_s *testaccount = (account_s*)account; + + account_query_capability_by_account_id(_account_get_capability_text_cb, testaccount->id, (void*)testaccount); + _account_query_custom_by_account_id(_account_get_custom_text_cb, testaccount->id, (void*)testaccount); + + ACCOUNT_CATCH_ERROR(callback(account, user_data) == TRUE, {}, ACCOUNT_ERROR_NONE, ("callback returns false, it is stopped.\n")); + } + + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (account_head) { + if (account_head->account_list) { + _account_glist_free(account_head->account_list); + account_head->account_list = NULL; + _account_free_account_items(account_head); + } + _ACCOUNT_FREE(account_head); + } + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +ACCOUNT_API int account_query_account_by_capability(account_cb callback, const char* capability_type, account_capability_state_e capability_value, void* user_data) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((capability_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("capability_type IS NULL")); + + if (((int)capability_value < 0) || (capability_value > ACCOUNT_CAPABILITY_STATE_MAX)) { + ACCOUNT_SLOGE("(%s)-(%d) capability_value is not equal to 0 or 1.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("CALL BACK IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id IN (SELECT account_id from %s WHERE key=? AND value=?)", ACCOUNT_TABLE, CAPABILITY_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + int binding_count = 1; + _account_query_bind_text(hstmt, binding_count++, capability_type); + _account_query_bind_int(hstmt, binding_count++, (int)capability_value); + + rc = _account_query_step(hstmt); + + account_s* account_head = NULL; + + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + int tmp = 0; + + account_head = (account_s*) malloc(sizeof(account_s)); + if (account_head == NULL) { + ACCOUNT_FATAL("malloc Failed"); + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + return ACCOUNT_ERROR_OUT_OF_MEMORY; + } + ACCOUNT_MEMSET(account_head, 0x00, sizeof(account_s)); + + while (rc == SQLITE_ROW) { + account_s* account_record = NULL; + + account_record = (account_s*) malloc(sizeof(account_s)); + + if (account_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s)); + + _account_convert_column_to_account(hstmt, account_record); + + account_head->account_list = g_list_append(account_head->account_list, account_record); + + rc = _account_query_step(hstmt); + tmp++; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_CATCH_ERROR((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + GList *iter; + + + tmp = g_list_length(account_head->account_list); + + for (iter = account_head->account_list; iter != NULL; iter = g_list_next(iter)) { + account_h account = NULL; + account = (account_h)iter->data; + account_s* testaccount = (account_s*)account; + + account_query_capability_by_account_id(_account_get_capability_text_cb, testaccount->id, (void*)testaccount); + _account_query_custom_by_account_id(_account_get_custom_text_cb, testaccount->id, (void*)testaccount); + + ACCOUNT_CATCH_ERROR(callback(account, user_data) == TRUE, {}, ACCOUNT_ERROR_NONE, ("callback returns false, it is stopped.\n")); + } + + + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (account_head) { + if (account_head->account_list) { + _account_glist_free(account_head->account_list); + account_head->account_list = NULL; + _account_free_account_items(account_head); + } + _ACCOUNT_FREE(account_head); + } + + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +ACCOUNT_API int account_query_account_by_capability_type(account_cb callback, const char* capability_type, void* user_data) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((capability_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("capability_type IS NULL")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("CALL BACK IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE _id IN (SELECT account_id from %s WHERE key=?)", ACCOUNT_TABLE, CAPABILITY_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + int binding_count = 1; + _account_query_bind_text(hstmt, binding_count++, capability_type); + + rc = _account_query_step(hstmt); + + account_s* account_head = NULL; + + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + int tmp = 0; + + account_head = (account_s*) malloc(sizeof(account_s)); + if (account_head == NULL) { + ACCOUNT_FATAL("malloc Failed"); + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + return ACCOUNT_ERROR_OUT_OF_MEMORY; + } + ACCOUNT_MEMSET(account_head, 0x00, sizeof(account_s)); + + while (rc == SQLITE_ROW) { + account_s* account_record = NULL; + + account_record = (account_s*) malloc(sizeof(account_s)); + + if (account_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s)); + + _account_convert_column_to_account(hstmt, account_record); + + account_head->account_list = g_list_append(account_head->account_list, account_record); + + rc = _account_query_step(hstmt); + tmp++; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_CATCH_ERROR((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + GList *iter; + + + tmp = g_list_length(account_head->account_list); + + for (iter = account_head->account_list; iter != NULL; iter = g_list_next(iter)) { + account_h account = NULL; + account = (account_h)iter->data; + account_s* testaccount = (account_s*)account; + + account_query_capability_by_account_id(_account_get_capability_text_cb, testaccount->id, (void*)testaccount); + _account_query_custom_by_account_id(_account_get_custom_text_cb, testaccount->id, (void*)testaccount); + + ACCOUNT_CATCH_ERROR(callback(account, user_data) == TRUE, {}, ACCOUNT_ERROR_NONE, ("The record isn't found.\n")); + + } + + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (account_head) { + if (account_head->account_list) { + _account_glist_free(account_head->account_list); + account_head->account_list = NULL; + _account_free_account_items(account_head); + } + _ACCOUNT_FREE(account_head); + } + + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +ACCOUNT_API int account_query_account_by_package_name(account_cb callback, const char* package_name, void* user_data) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((package_name != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("PACKAGE NAME IS NULL")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("CALL BACK IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE package_name=?", ACCOUNT_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + int binding_count = 1; + _account_query_bind_text(hstmt, binding_count++, package_name); + + rc = _account_query_step(hstmt); + + account_s* account_head = NULL; + + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.(%s)\n", package_name)); + + int tmp = 0; + + account_head = (account_s*) malloc(sizeof(account_s)); + if (account_head == NULL) { + ACCOUNT_FATAL("malloc Failed"); + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + return ACCOUNT_ERROR_OUT_OF_MEMORY; + } + ACCOUNT_MEMSET(account_head, 0x00, sizeof(account_s)); + + while (rc == SQLITE_ROW) { + account_s* account_record = NULL; + + account_record = (account_s*) malloc(sizeof(account_s)); + + if (account_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + ACCOUNT_MEMSET(account_record, 0x00, sizeof(account_s)); + + _account_convert_column_to_account(hstmt, account_record); + + account_head->account_list = g_list_append(account_head->account_list, account_record); + + rc = _account_query_step(hstmt); + tmp++; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_CATCH_ERROR((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + GList *iter; + + tmp = g_list_length(account_head->account_list); + + for (iter = account_head->account_list; iter != NULL; iter = g_list_next(iter)) { + account_h account = NULL; + account = (account_h)iter->data; + + account_s* testaccount = (account_s*)account; + + account_query_capability_by_account_id(_account_get_capability_text_cb, testaccount->id, (void*)testaccount); + _account_query_custom_by_account_id(_account_get_custom_text_cb, testaccount->id, (void*)testaccount); + + ACCOUNT_CATCH_ERROR(callback(account, user_data) == TRUE, {}, ACCOUNT_ERROR_NONE, ("The record isn't found.\n")); + + } + + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (account_head) { + if (account_head->account_list) { + _account_glist_free(account_head->account_list); + account_head->account_list = NULL; + _account_free_account_items(account_head); + } + _ACCOUNT_FREE(account_head); + } + + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +ACCOUNT_API int account_delete(int account_id) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + int ret_transaction = 0; + bool is_success = FALSE; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + int count = -1; + /* Check requested ID to delete */ + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE _id=%d", ACCOUNT_TABLE, account_id); + + count = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (count <= 0) { + ACCOUNT_ERROR("account id(%d) is not exist. count(%d)\n", account_id, count); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + /* Check permission of requested appid */ + char* current_appid = NULL; + char *package_name = NULL; + + current_appid = _account_get_current_appid(); + + error_code = _account_get_package_name_from_account_id(account_id, &package_name); + + if(error_code != ACCOUNT_ERROR_NONE){ + ACCOUNT_ERROR("No package name with account_id\n"); + _ACCOUNT_FREE(current_appid); + _ACCOUNT_FREE(package_name); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + ACCOUNT_DEBUG( "DELETE:account_id[%d],current_appid[%s]package_name[%s]", account_id, current_appid, package_name); + + error_code = _account_check_appid_group_with_package_name(current_appid, package_name); + + _ACCOUNT_FREE(current_appid); + _ACCOUNT_FREE(package_name); + + if(error_code != ACCOUNT_ERROR_NONE){ + ACCOUNT_ERROR("No permission to delete\n"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + /* transaction control required*/ + ret_transaction = _account_begin_transaction(); + + if( _account_db_err_code() == SQLITE_PERM ){ + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if( ret_transaction == ACCOUNT_ERROR_DATABASE_BUSY ){ + ACCOUNT_ERROR( "database busy(%s)", _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_DATABASE_BUSY; + } + + if (ret_transaction != ACCOUNT_ERROR_NONE) { + ACCOUNT_ERROR("account_delete:_account_begin_transaction fail %d\n", ret_transaction); + pthread_mutex_unlock(&account_mutex); + return ret_transaction; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE account_id = %d", CAPABILITY_TABLE, account_id); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + rc = _account_query_finalize(hstmt); + + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + ACCOUNT_MEMSET(query, 0, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE _id = %d", ACCOUNT_TABLE, account_id); + + hstmt = _account_prepare_query(query); + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found. id=%d, rc=%d\n", account_id, rc)); + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + /* delete custom data */ + ACCOUNT_MEMSET(query, 0, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AccountId = %d", ACCOUNT_CUSTOM_TABLE, account_id); + + hstmt = _account_prepare_query(query); + + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found. id=%d, rc=%d\n", account_id, rc)); + + rc = _account_query_finalize(hstmt); + ACCOUNT_CATCH_ERROR(rc == ACCOUNT_ERROR_NONE, {}, rc, ("finalize error", account_id, rc)); + hstmt = NULL; + + is_success = TRUE; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + if(rc != ACCOUNT_ERROR_NONE ){ + ACCOUNT_ERROR("rc (%d)", rc); + is_success = FALSE; + } + + hstmt = NULL; + } + + ret_transaction = _account_end_transaction(is_success); + + if (ret_transaction != ACCOUNT_ERROR_NONE) { + ACCOUNT_ERROR("account_delete:_account_end_transaction fail %d, is_success=%d\n", ret_transaction, is_success); + } else { + if (is_success == true) { + char buf[64]={0,}; + ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", ACCOUNT_NOTI_NAME_DELETE, account_id); + _account_insert_delete_update_notification_send(buf); + } + } + + pthread_mutex_unlock(&account_mutex); + + return error_code; + +} + +ACCOUNT_API int account_delete_from_db_by_id(int account_db_id) +{ + ACCOUNT_RETURN_VAL((account_db_id > 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT ID IS LESS THAN ZERO.")); + + return account_delete(account_db_id); +} + +static int _account_query_account_by_username_and_package(const char* username, const char* package_name, account_h *account) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + int binding_count = 1; + + ACCOUNT_RETURN_VAL((username != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("username IS NULL")); + ACCOUNT_RETURN_VAL((package_name != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("package_name IS NULL")); + ACCOUNT_RETURN_VAL((*account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE user_name = ? and package_name = ?", ACCOUNT_TABLE); + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + _account_query_bind_text(hstmt, binding_count++, username); + _account_query_bind_text(hstmt, binding_count++, package_name); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + account_s *account_record = (account_s *)(*account); + + while (rc == SQLITE_ROW) { + _account_convert_column_to_account(hstmt, account_record); + rc = _account_query_step(hstmt); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + account_query_capability_by_account_id(_account_get_capability_text_cb, account_record->id, (void*)account_record); + _account_query_custom_by_account_id(_account_get_custom_text_cb, account_record->id, (void*)account_record); + + hstmt = NULL; + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +ACCOUNT_API int account_delete_from_db_by_user_name(char *user_name, char *package_name) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + int ret_transaction = 0; + bool is_success = FALSE; + account_h account = NULL; + int binding_count = 1; + int account_id = -1; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((user_name != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("user_name is null!")); + ACCOUNT_RETURN_VAL((package_name != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("package_name is null!")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + rc = account_create(&account); + rc = _account_query_account_by_username_and_package(user_name, package_name, &account); + + + if( _account_db_err_code() == SQLITE_PERM ){ + account_destroy(account); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + rc = account_get_account_id(account, &account_id); + + rc = account_destroy(account); + + /* transaction control required*/ + ret_transaction = _account_begin_transaction(); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if( ret_transaction == ACCOUNT_ERROR_DATABASE_BUSY ){ + ACCOUNT_ERROR( "database busy(%s)", _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_DATABASE_BUSY; + }else if (ret_transaction != ACCOUNT_ERROR_NONE) { + ACCOUNT_ERROR("account_delete:_account_begin_transaction fail %d\n", ret_transaction); + pthread_mutex_unlock(&account_mutex); + return ret_transaction; + } + + /* delete custom data */ + ACCOUNT_MEMSET(query, 0, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AccountId = ?", ACCOUNT_CUSTOM_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + _account_end_transaction(FALSE); + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + _account_query_bind_int(hstmt, binding_count++, account_id); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + /* delete capability */ + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE user_name = ? and package_name = ?", CAPABILITY_TABLE); + + hstmt = _account_prepare_query(query); + + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + binding_count = 1; + _account_query_bind_text(hstmt, binding_count++, user_name); + _account_query_bind_text(hstmt, binding_count++, package_name); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + ACCOUNT_MEMSET(query, 0, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE user_name = ? and package_name = ?", ACCOUNT_TABLE); + + hstmt = _account_prepare_query(query); + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + binding_count = 1; + _account_query_bind_text(hstmt, binding_count++, user_name); + _account_query_bind_text(hstmt, binding_count++, package_name); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found. user_name=%s, package_name=%s, rc=%d\n", user_name, package_name, rc)); + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + is_success = TRUE; + + hstmt = NULL; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + ret_transaction = _account_end_transaction(is_success); + + if (ret_transaction != ACCOUNT_ERROR_NONE) { + ACCOUNT_ERROR("account_svc_delete:_account_svc_end_transaction fail %d, is_success=%d\n", ret_transaction, is_success); + } else { + if (is_success == true) { + char buf[64]={0,}; + ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%d", ACCOUNT_NOTI_NAME_DELETE, account_id); + _account_insert_delete_update_notification_send(buf); + } + } + + pthread_mutex_unlock(&account_mutex); + + return error_code; +} + +static bool _account_delete_from_db_by_package_name_cb(account_h account, void *user_data) +{ + GSList **account_id_list = (GSList**)user_data; + int account_id = 0; + char id_buf[10] ={0,}; + char* tmp_ptr = NULL; + + account_get_account_id(account, &account_id); + ACCOUNT_SNPRINTF(id_buf, sizeof(id_buf), "%d", account_id); + + tmp_ptr = strdup(id_buf); + + ACCOUNT_SLOGD("id = %s", id_buf); + + *account_id_list = g_slist_append(*account_id_list, tmp_ptr); + + return TRUE; +} + +ACCOUNT_API int account_delete_from_db_by_package_name(const char *package_name) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + int ret_transaction = 0; + bool is_success = FALSE; + int binding_count = 1; + GSList *account_id_list = NULL; + int ret = -1; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((package_name != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("package_name is null!")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ret = account_query_account_by_package_name(_account_delete_from_db_by_package_name_cb, package_name, (void*)&account_id_list); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if(ret != ACCOUNT_ERROR_NONE){ + return ret; + } + + /* transaction control required*/ + ret_transaction = _account_begin_transaction(); + + if( _account_db_err_code() == SQLITE_PERM ){ + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if( ret_transaction == ACCOUNT_ERROR_DATABASE_BUSY ){ + ACCOUNT_ERROR( "database busy(%s)", _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_DATABASE_BUSY; + }else if (ret_transaction != ACCOUNT_ERROR_NONE) { + ACCOUNT_ERROR("account_delete:_account_begin_transaction fail %d\n", ret_transaction); + pthread_mutex_unlock(&account_mutex); + return ret_transaction; + } + + /* delete custom table */ + ACCOUNT_MEMSET(query, 0, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AppId = ?", ACCOUNT_CUSTOM_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + _account_end_transaction(FALSE); + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + binding_count = 1; + _account_query_bind_text(hstmt, binding_count++, package_name); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + /* delete capability table */ + ACCOUNT_MEMSET(query, 0, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE package_name = ?", CAPABILITY_TABLE); + + hstmt = _account_prepare_query(query); + + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + binding_count = 1; + _account_query_bind_text(hstmt, binding_count++, package_name); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + /* delete account table */ + ACCOUNT_MEMSET(query, 0, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE package_name = ?", ACCOUNT_TABLE); + + hstmt = _account_prepare_query(query); + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + binding_count = 1; + _account_query_bind_text(hstmt, binding_count++, package_name); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found. package_name=%s, rc=%d\n", package_name, rc)); + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + is_success = TRUE; + + hstmt = NULL; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + ret_transaction = _account_end_transaction(is_success); + + if (ret_transaction != ACCOUNT_ERROR_NONE) { + ACCOUNT_ERROR("account_delete:_account_end_transaction fail %d, is_success=%d\n", ret_transaction, is_success); + } else { + if (is_success == true) { + GSList* iter; + for (iter = account_id_list; iter != NULL; iter = g_slist_next(iter)) { + char* p_tmpid = NULL; + p_tmpid = (char*)iter->data; + char buf[64]={0,}; + ACCOUNT_SNPRINTF(buf, sizeof(buf), "%s:%s", ACCOUNT_NOTI_NAME_DELETE, p_tmpid); + ACCOUNT_SLOGD("%s", buf); + _account_insert_delete_update_notification_send(buf); + _ACCOUNT_FREE(p_tmpid); + } + g_slist_free(account_id_list); + } + } + + pthread_mutex_unlock(&account_mutex); + + return error_code; +} + +ACCOUNT_API int account_get_total_count_from_db(int *count) +{ + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + if (!count) { + ACCOUNT_SLOGE("(%s)-(%d) count is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if(!g_hAccountDB){ + ACCOUNT_ERROR("DB is not opened\n"); + return ACCOUNT_ERROR_DB_NOT_OPENED; + } + + char query[1024] = {0, }; + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "select count(*) from %s", ACCOUNT_TABLE); + + *count = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + int rc = -1; + int ncount = 0; + account_stmt pStmt = NULL; + + rc = sqlite3_prepare_v2(g_hAccountDB, query, strlen(query), &pStmt, NULL); + if (SQLITE_OK != rc) { + ACCOUNT_SLOGE("sqlite3_prepare_v2() failed(%d, %s).", rc, _account_db_err_msg()); + sqlite3_finalize(pStmt); + return ACCOUNT_ERROR_DB_FAILED; + } + + rc = sqlite3_step(pStmt); + if (SQLITE_ROW != rc) { + ACCOUNT_ERROR("[ERROR] sqlite3_step() failed\n"); + sqlite3_finalize(pStmt); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + ncount = sqlite3_column_int(pStmt, 0); + + *count = ncount; + + sqlite3_finalize(pStmt); + + if (ncount < 0) { + ACCOUNT_ERROR("[ERROR] Number of account : %d, End", ncount); + return ACCOUNT_ERROR_DB_FAILED; + } + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_destroy(account_h account) +{ + account_s *data = (account_s*)account; + + ACCOUNT_RETURN_VAL((data != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Account handle is null!")); + + _account_free_account_items(data); + _ACCOUNT_FREE(data); + + return ACCOUNT_ERROR_NONE; +} + +static int _account_type_free_label_items(label_s *data) +{ + _ACCOUNT_FREE(data->app_id); + _ACCOUNT_FREE(data->label); + _ACCOUNT_FREE(data->locale); + + return ACCOUNT_ERROR_NONE; +} + +static int _account_type_free_feature_items(provider_feature_s *data) +{ + _ACCOUNT_FREE(data->app_id); + _ACCOUNT_FREE(data->key); + + return ACCOUNT_ERROR_NONE; +} + +static int _account_type_gslist_free(GSList* list) +{ + ACCOUNT_RETURN_VAL((list != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("GSlist is NULL")); + + GSList* iter; + + for (iter = list; iter != NULL; iter = g_slist_next(iter)) { + label_s *label_data = (label_s*)iter->data; + _account_type_free_label_items(label_data); + _ACCOUNT_FREE(label_data); + } + + g_slist_free(list); + list = NULL; + + return ACCOUNT_ERROR_NONE; +} + +static int _account_type_item_free(account_type_s *data) +{ + _ACCOUNT_FREE(data->app_id); + _ACCOUNT_FREE(data->service_provider_id); + _ACCOUNT_FREE(data->icon_path); + _ACCOUNT_FREE(data->small_icon_path); + + return ACCOUNT_ERROR_NONE; +} + +static int _account_type_glist_free(GList* list) +{ + ACCOUNT_RETURN_VAL((list != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Glist is NULL")); + + GList* iter; + + for (iter = list; iter != NULL; iter = g_list_next(iter)) { + account_type_s *account_type_record = (account_type_s*)iter->data; + _account_type_item_free(account_type_record); + _ACCOUNT_FREE(account_type_record); + } + + g_list_free(list); + list = NULL; + + return ACCOUNT_ERROR_NONE; +} + +static int _account_type_free_account_type_items(account_type_s *data) +{ + _account_type_item_free(data); + + _account_type_gslist_free(data->label_list); + _account_type_glist_free(data->account_type_list); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_create(account_type_h *account_type) +{ + if (!account_type) { + ACCOUNT_SLOGE("(%s)-(%d) account type handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_type_s *data = (account_type_s*)malloc(sizeof(account_type_s)); + + if (data == NULL) { + ACCOUNT_ERROR("Memory Allocation Failed"); + return ACCOUNT_ERROR_OUT_OF_MEMORY; + } + + ACCOUNT_MEMSET(data, 0, sizeof(account_type_s)); + + *account_type = (account_type_h)data; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_destroy(account_type_h account_type) +{ + account_type_s *data = (account_type_s*)account_type; + + ACCOUNT_RETURN_VAL((data != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Account type handle is null!")); + + _account_type_free_account_type_items(data); + _ACCOUNT_FREE(data); + + return ACCOUNT_ERROR_NONE; +} + +//app_id mandatory field +ACCOUNT_API int account_type_set_app_id(account_type_h account_type, const char *app_id) +{ + if (!account_type) { + ACCOUNT_SLOGE("(%s)-(%d) account_type handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!app_id) { + ACCOUNT_SLOGE("(%s)-(%d) app_id is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_type_s *data = (account_type_s*)account_type; + + _ACCOUNT_FREE(data->app_id); + data->app_id = _account_get_text(app_id); + + return ACCOUNT_ERROR_NONE; +} + +//service_provider_id mandatory field +ACCOUNT_API int account_type_set_service_provider_id(account_type_h account_type, const char *service_provider_id) +{ + if (!account_type) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!service_provider_id) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_type_s *data = (account_type_s*)account_type; + + _ACCOUNT_FREE(data->service_provider_id); + data->service_provider_id = _account_get_text(service_provider_id); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_set_icon_path(account_type_h account_type, const char *icon_path) +{ + if (!account_type) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!icon_path) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_type_s *data = (account_type_s*)account_type; + + _ACCOUNT_FREE(data->icon_path); + data->icon_path = _account_get_text(icon_path); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_set_small_icon_path(account_type_h account_type, const char *small_icon_path) +{ + if (!account_type) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!small_icon_path) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_type_s *data = (account_type_s*)account_type; + + _ACCOUNT_FREE(data->small_icon_path); + data->small_icon_path = _account_get_text(small_icon_path); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_set_multiple_account_support(account_type_h account_type, const bool multiple_account_support) +{ + ACCOUNT_RETURN_VAL((account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("(%s)-(%d) account handle is NULL.\n", __FUNCTION__, __LINE__)); + + account_type_s *data = (account_type_s*)account_type; + + data->multiple_account_support = multiple_account_support; + + return ACCOUNT_ERROR_NONE; +} + +// unset? +ACCOUNT_API int account_type_set_label(account_type_h account_type, const char* label, const char* locale) +{ + if (!account_type) { + ACCOUNT_SLOGE("(%s)-(%d) account_type handle is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if(!label || !locale) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_type_s *data = (account_type_s*)account_type; + label_s *label_data = (label_s*)malloc(sizeof(label_s)); + + if (label_data == NULL) { + return ACCOUNT_ERROR_OUT_OF_MEMORY; + } + ACCOUNT_MEMSET(label_data, 0, sizeof(label_s)); + + label_data->label = _account_get_text(label); + label_data->locale = _account_get_text(locale); + + data->label_list = g_slist_append(data->label_list, (gpointer)label_data); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_get_app_id(account_type_h account_type, char **app_id) +{ + if (!account_type) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!app_id) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_type_s *data = (account_type_s*)account_type; + + (*app_id) = NULL; + *app_id = _account_get_text(data->app_id); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_get_service_provider_id(account_type_h account_type, char **service_provider_id) +{ + if (!account_type) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!service_provider_id) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_type_s *data = (account_type_s*)account_type; + + (*service_provider_id) = NULL; + *service_provider_id = _account_get_text(data->service_provider_id); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_get_icon_path(account_type_h account_type, char **icon_path) +{ + if (!account_type) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!icon_path) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_type_s *data = (account_type_s*)account_type; + + (*icon_path) = NULL; + *icon_path = _account_get_text(data->icon_path); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_get_small_icon_path(account_type_h account_type, char **small_icon_path) +{ + if (!account_type) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!small_icon_path) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_type_s *data = (account_type_s*)account_type; + + (*small_icon_path) = NULL; + *small_icon_path = _account_get_text(data->small_icon_path); + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_get_multiple_account_support(account_type_h account_type, int *multiple_account_support) +{ + if (!account_type) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + if (!multiple_account_support) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_type_s *data = (account_type_s*)account_type; + + *multiple_account_support = data->multiple_account_support; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_get_label_by_locale(account_type_h account_type, const char* locale, char** label) +{ + ACCOUNT_RETURN_VAL((account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + ACCOUNT_RETURN_VAL((label != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("INVALID PARAMETER")); + + GSList *iter; + account_type_s *data = (account_type_s*)account_type; + + for (iter = data->label_list; iter != NULL; iter = g_slist_next(iter)) { + label_s *label_data = NULL; + + label_data = (label_s*)iter->data; + + *label = NULL; + + if(!strcmp(locale, label_data->locale)) { + *label = _account_get_text(label_data->label); + return ACCOUNT_ERROR_NONE; + } + gchar** tokens = g_strsplit(locale, "-", 2); + if(tokens != NULL) { + if((char*)(tokens[1]) != NULL) { + char* upper_token = g_ascii_strup(tokens[1], strlen(tokens[1])); + if(upper_token != NULL) { + char* converted_locale = g_strdup_printf("%s_%s", tokens[0], upper_token); + if(!strcmp(converted_locale, label_data->locale)) { + _ACCOUNT_FREE(converted_locale); + _ACCOUNT_FREE(upper_token); + g_strfreev(tokens); + *label = _account_get_text(label_data->label); + return ACCOUNT_ERROR_NONE; + } + _ACCOUNT_FREE(converted_locale); + } + _ACCOUNT_FREE(upper_token); + } + } + g_strfreev(tokens); + } + + return ACCOUNT_ERROR_RECORD_NOT_FOUND; +} + +ACCOUNT_API int account_type_get_label(account_type_h account_type, account_label_cb callback, void *user_data) +{ + ACCOUNT_RETURN_VAL((account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION")); + + GSList *iter; + account_type_s *data = (account_type_s*)account_type; + + for (iter = data->label_list; iter != NULL; iter = g_slist_next(iter)) { + label_s *label_data = NULL; + + label_data = (label_s*)iter->data; + + if(callback(label_data->app_id, label_data->label, label_data->locale, user_data)!=TRUE) { + ACCOUNT_DEBUG("Callback func returs FALSE, its iteration is stopped!!!!\n"); + return ACCOUNT_ERROR_NONE; + } + } + + return ACCOUNT_ERROR_NONE; +} + +static gboolean _account_type_check_duplicated(account_type_s *data) +{ + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int count = 0; + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE AppId='%s'" + , ACCOUNT_TYPE_TABLE, data->app_id); + + count = _account_get_record_count(query); + if (count > 0) { + return TRUE; + } + + return FALSE; +} + +static int _account_type_convert_account_to_sql(account_type_s *account_type, account_stmt hstmt, char *sql_value) +{ + int count = 1; + + /*Caution : Keep insert query orders.*/ + + /* 1. app id*/ + _account_query_bind_text(hstmt, count++, (char*)account_type->app_id); + + /* 2. service provider id*/ + _account_query_bind_text(hstmt, count++, (char*)account_type->service_provider_id); + + /* 3. icon path*/ + _account_query_bind_text(hstmt, count++, (char*)account_type->icon_path); + + /* 4. small icon path*/ + _account_query_bind_text(hstmt, count++, (char*)account_type->small_icon_path); + + /* 5. multiple accont support*/ + _account_query_bind_int(hstmt, count++, account_type->multiple_account_support); + + return count; +} + + +static int _account_type_execute_insert_query(account_type_s *account_type) +{ + int rc = 0; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + + /* check mandatory field */ + // app id & service provider id + if (!account_type->app_id) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s( AppId, ServiceProviderId , IconPath , SmallIconPath , MultipleAccountSupport ) values " + "(?, ?, ?, ?, ?)", ACCOUNT_TYPE_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } else if( _account_db_err_code() == SQLITE_BUSY ){ + ACCOUNT_ERROR( "Database Busy(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_DATABASE_BUSY; + } + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg())); + + _account_type_convert_account_to_sql(account_type, hstmt, query); + + rc = _account_query_step(hstmt); + if (rc == SQLITE_BUSY) { + ACCOUNT_ERROR( "account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + error_code = ACCOUNT_ERROR_DATABASE_BUSY; + } else if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + error_code = ACCOUNT_ERROR_DB_FAILED; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + return error_code; +} + +static int _account_type_insert_label(account_type_s *account_type) +{ + int rc, count = 1; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + account_stmt hstmt = NULL; + + ACCOUNT_RETURN_VAL((account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + + if (g_slist_length( account_type->label_list)==0) { + ACCOUNT_ERROR( "_account_type_insert_label, no label\n"); + return ACCOUNT_ERROR_NONE; + } + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where AppId = '%s'", ACCOUNT_TYPE_TABLE, account_type->app_id); + + rc = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (rc <= 0) { + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + /* insert query*/ + GSList *iter; + + for (iter = account_type->label_list; iter != NULL; iter = g_slist_next(iter)) { + int ret; + count = 1; + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(AppId, Label, Locale) VALUES " + "(?, ?, ?) ", LABEL_TABLE); + + hstmt = _account_prepare_query(query); + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg())); + + label_s* label_data = NULL; + label_data = (label_s*)iter->data; + + ret = _account_query_bind_text(hstmt, count++, account_type->app_id); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, label_data->label); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)label_data->locale); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + break; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + } + + return ACCOUNT_ERROR_NONE; +} + +static void _account_type_convert_column_to_provider_feature(account_stmt hstmt, provider_feature_s *feature_record) +{ + const char *textbuf = NULL; + + textbuf = _account_query_table_column_text(hstmt, PROVIDER_FEATURE_FIELD_APP_ID); + _account_db_data_to_text(textbuf, &(feature_record->app_id)); + + textbuf = _account_query_table_column_text(hstmt, PROVIDER_FEATURE_FIELD_KEY); + _account_db_data_to_text(textbuf, &(feature_record->key)); + +} + +ACCOUNT_API int account_type_query_provider_feature_by_app_id(provider_feature_cb callback, const char* app_id, void *user_data ) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0, binding_count = 1; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((app_id != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE app_id = ?", PROVIDER_FEATURE_TABLE); + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + _account_query_bind_text(hstmt, binding_count++, app_id); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + provider_feature_s* feature_record = NULL; + + while (rc == SQLITE_ROW) { + bool cb_ret = FALSE; + feature_record = (provider_feature_s*) malloc(sizeof(provider_feature_s)); + + if (feature_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + + ACCOUNT_MEMSET(feature_record, 0x00, sizeof(provider_feature_s)); + + _account_type_convert_column_to_provider_feature(hstmt, feature_record); + + cb_ret = callback(feature_record->app_id, feature_record->key, user_data); + + _account_type_free_feature_items(feature_record); + _ACCOUNT_FREE(feature_record); + + ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n")); + + rc = _account_query_step(hstmt); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +ACCOUNT_API bool account_type_query_supported_feature(const char* app_id, const char* capability) +{ + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int record_count = 0; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + set_last_result(ACCOUNT_ERROR_PERMISSION_DENIED); + return false; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + set_last_result(ACCOUNT_ERROR_PERMISSION_DENIED); + return false; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + set_last_result(ACCOUNT_ERROR_PERMISSION_DENIED); + return false; + } + close(fd); + } + + if (app_id == NULL || capability == NULL) { + set_last_result(ACCOUNT_ERROR_INVALID_PARAMETER); + return false; + } + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s where app_id='%s' and key='%s'", PROVIDER_FEATURE_TABLE, app_id, capability); + + record_count = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + set_last_result(ACCOUNT_ERROR_PERMISSION_DENIED); + return false; + } + + if (record_count <= 0) { + set_last_result(ACCOUNT_ERROR_RECORD_NOT_FOUND); + return false; + } + + set_last_result(ACCOUNT_ERROR_NONE); + return true; + +} + + +ACCOUNT_API int account_type_get_provider_feature_all(account_type_h account_type, provider_feature_cb callback, void* user_data) +{ + ACCOUNT_RETURN_VAL((account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION")); + + GSList *iter; + account_type_s *data = (account_type_s*)account_type; + + for (iter = data->provider_feature_list; iter != NULL; iter = g_slist_next(iter)) { + provider_feature_s *feature_data = NULL; + + feature_data = (provider_feature_s*)iter->data; + + if(callback(feature_data->app_id, feature_data->key, user_data)!=TRUE) { + ACCOUNT_DEBUG("Callback func returs FALSE, its iteration is stopped!!!!\n"); + return ACCOUNT_ERROR_NONE; + } + } + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_set_provider_feature(account_type_h account_type, const char* provider_feature) +{ + ACCOUNT_RETURN_VAL((account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("account type handle is null")); + ACCOUNT_RETURN_VAL((provider_feature != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("provider_feature is null")); + + account_type_s *data = (account_type_s*)account_type; + + GSList *iter = NULL; + bool b_is_new = TRUE; + + for(iter = data->provider_feature_list; iter != NULL; iter = g_slist_next(iter)) { + provider_feature_s *feature_data = NULL; + feature_data = (provider_feature_s*)iter->data; + + if(!strcmp(feature_data->key, provider_feature)) { + b_is_new = FALSE; + break; + } + } + + if(b_is_new) { + provider_feature_s* feature_data = (provider_feature_s*)malloc(sizeof(provider_feature_s)); + + if (feature_data == NULL) + return ACCOUNT_ERROR_OUT_OF_MEMORY; + ACCOUNT_MEMSET(feature_data, 0, sizeof(provider_feature_s)); + + feature_data->key = _account_get_text(provider_feature); + data->provider_feature_list = g_slist_append(data->provider_feature_list, (gpointer)feature_data); + } + + return ACCOUNT_ERROR_NONE; +} + +static int _account_type_insert_provider_feature(account_type_s *account_type, const char* app_id) +{ + int rc, count = 1; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + account_stmt hstmt = NULL; + + ACCOUNT_RETURN_VAL((account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + ACCOUNT_RETURN_VAL((app_id != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL")); + + if (g_slist_length( account_type->provider_feature_list)==0) { + ACCOUNT_ERROR( "no capability\n"); + return ACCOUNT_ERROR_NONE; + } + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where AppId='%s'", ACCOUNT_TYPE_TABLE, app_id); + + rc = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (rc <= 0) { + ACCOUNT_SLOGI( "related account type item is not existed rc=%d , %s", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + /* insert query*/ + + GSList *iter; + + for (iter = account_type->provider_feature_list; iter != NULL; iter = g_slist_next(iter)) { + int ret; + count = 1; + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(app_id, key) VALUES " + "(?, ?) ", PROVIDER_FEATURE_TABLE); + + hstmt = _account_prepare_query(query); + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg())); + + provider_feature_s* feature_data = NULL; + feature_data = (provider_feature_s*)iter->data; + + ret = _account_query_bind_text(hstmt, count++, app_id); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, feature_data->key); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Integer binding fail")); + + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + break; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + } + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_insert_to_db(account_type_h account_type, int* account_type_id) +{ + int error_code = ACCOUNT_ERROR_NONE, ret_transaction = 0; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + ACCOUNT_RETURN_VAL((account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT TYPE HANDLE IS NULL")); + ACCOUNT_RETURN_VAL((account_type_id != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT TYPE ID POINTER IS NULL")); + + account_type_s *data = (account_type_s*)account_type; + + pthread_mutex_lock(&account_mutex); + + + /* transaction control required*/ + ret_transaction = _account_begin_transaction(); + + if( _account_db_err_code() == SQLITE_PERM ){ + pthread_mutex_unlock(&account_mutex); + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if( ret_transaction == ACCOUNT_ERROR_DATABASE_BUSY ){ + ACCOUNT_ERROR( "database busy(%s)", _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_DATABASE_BUSY; + } else if (ret_transaction != ACCOUNT_ERROR_NONE) { + ACCOUNT_ERROR("_account_begin_transaction fail %d\n", ret_transaction); + pthread_mutex_unlock(&account_mutex); + return ret_transaction; + } + + if (_account_type_check_duplicated(data)) { + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("Duplicated, rollback insert query(%x)!!!!\n", ret_transaction); + *account_type_id = -1; + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_DUPLICATED; + } else { + *account_type_id = _account_get_next_sequence(ACCOUNT_TYPE_TABLE); + + error_code = _account_type_execute_insert_query(data); + + if (error_code != ACCOUNT_ERROR_NONE){ + error_code = ACCOUNT_ERROR_DUPLICATED; + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("Insert fail, rollback insert query(%x)!!!!\n", ret_transaction); + *account_type_id = -1; + pthread_mutex_unlock(&account_mutex); + return error_code; + } + } + + error_code = _account_type_insert_provider_feature(data, data->app_id); + if(error_code != ACCOUNT_ERROR_NONE) { + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("Insert provider feature fail(%x), rollback insert query(%x)!!!!\n", error_code, ret_transaction); + pthread_mutex_unlock(&account_mutex); + return error_code; + } + error_code = _account_type_insert_label(data); + if(error_code != ACCOUNT_ERROR_NONE) { + ret_transaction = _account_end_transaction(FALSE); + ACCOUNT_ERROR("Insert label fail(%x), rollback insert query(%x)!!!!\n", error_code, ret_transaction); + pthread_mutex_unlock(&account_mutex); + return error_code; + } + + ret_transaction = _account_end_transaction(TRUE); + + pthread_mutex_unlock(&account_mutex); + + return ACCOUNT_ERROR_NONE; +} + +static int _account_type_update_provider_feature(account_type_s *account_type, const char* app_id) +{ + int rc, count = 1; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + account_stmt hstmt = NULL; + + ACCOUNT_RETURN_VAL((account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + + if (g_slist_length( account_type->provider_feature_list)==0) { + ACCOUNT_ERROR( "no feature\n"); + return ACCOUNT_ERROR_NONE; + } + + ACCOUNT_DEBUG( "app id", app_id); + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE app_id=? ", PROVIDER_FEATURE_TABLE); + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + count = 1; + _account_query_bind_text(hstmt, count++, app_id); + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_DB_FAILED; + } + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + GSList *iter; + + for (iter = account_type->provider_feature_list; iter != NULL; iter = g_slist_next(iter)) { + int ret; + count = 1; + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(app_id, key) VALUES " + "(?, ?) ", PROVIDER_FEATURE_TABLE); + + hstmt = _account_prepare_query(query); + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg())); + + provider_feature_s* feature_data = NULL; + feature_data = (provider_feature_s*)iter->data; + + ret = _account_query_bind_text(hstmt, count++, account_type->app_id); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, feature_data->key); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + break; + } + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + return ACCOUNT_ERROR_NONE; +} + +static int _account_type_update_label(account_type_s *account_type, const char* app_id) +{ + int rc, count = 1; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + account_stmt hstmt = NULL; + + ACCOUNT_RETURN_VAL((account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + + if (g_slist_length( account_type->label_list)==0) { + return ACCOUNT_ERROR_NONE; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AppId=? ", LABEL_TABLE); + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + count = 1; + _account_query_bind_text(hstmt, count++, app_id); + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_DB_FAILED; + } + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + GSList *iter; + + for (iter = account_type->label_list; iter != NULL; iter = g_slist_next(iter)) { + int ret; + count = 1; + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(AppId, Label, Locale) VALUES " + "(?, ?, ?) ", LABEL_TABLE); + + hstmt = _account_prepare_query(query); + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg())); + + label_s* label_data = NULL; + label_data = (label_s*)iter->data; + + ret = _account_query_bind_text(hstmt, count++, account_type->app_id); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, label_data->label); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, label_data->locale); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + break; + } + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + return ACCOUNT_ERROR_NONE; +} + + +static int _account_type_update_account(account_type_s *account_type, const char* app_id) +{ + int rc = 0, binding_count =1; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + + if (!account_type->app_id) { + ACCOUNT_ERROR("app id is mandetory field, it can not be NULL!!!!\n"); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "UPDATE %s SET AppId=?, ServiceProviderId=?, IconPath=?, " + "SmallIconPath=?, MultipleAccountSupport=? WHERE AppId=? ", ACCOUNT_TYPE_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } else if (_account_db_err_code() == SQLITE_BUSY){ + ACCOUNT_ERROR( "database busy(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_DATABASE_BUSY; + } + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_svc_query_prepare() failed(%s).\n", _account_db_err_msg())); + + binding_count = _account_type_convert_account_to_sql(account_type, hstmt, query); + _account_query_bind_text(hstmt, binding_count++, app_id); + + rc = _account_query_step(hstmt); + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "account_db_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + /*update label*/ + error_code = _account_type_update_label(account_type, app_id); + /* update provider feature */ + error_code = _account_type_update_provider_feature(account_type, app_id); + + return error_code; +} + +ACCOUNT_API int account_type_update_to_db_by_app_id(account_type_h account_type, const char* app_id) +{ + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("DATA IS NULL")); + ACCOUNT_RETURN_VAL((app_id != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + int error_code = ACCOUNT_ERROR_NONE; + account_type_s* data = (account_type_s*)account_type; + + pthread_mutex_lock(&account_mutex); + + error_code = _account_type_update_account(data, app_id); + + pthread_mutex_unlock(&account_mutex); + + return error_code; +} + +ACCOUNT_API int account_type_delete_by_app_id(const char* app_id) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0, count = -1; + int ret_transaction = 0; + int binding_count = 1; + bool is_success = FALSE; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + ACCOUNT_RETURN_VAL((app_id != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("The database isn't connected.")); + + /* Check requested ID to delete */ + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE AppId = '%s'", ACCOUNT_TYPE_TABLE, app_id); + + count = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (count <= 0) { + ACCOUNT_SLOGE("app id(%s) is not exist. count(%d)\n", app_id, count); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + /* transaction control required*/ + ret_transaction = _account_begin_transaction(); + + if( ret_transaction == ACCOUNT_ERROR_DATABASE_BUSY ){ + ACCOUNT_ERROR( "database busy(%s)", _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_DATABASE_BUSY; + }else if (ret_transaction != ACCOUNT_ERROR_NONE) { + ACCOUNT_ERROR("account_delete:_account_begin_transaction fail %d\n", ret_transaction); + pthread_mutex_unlock(&account_mutex); + return ret_transaction; + } + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AppId = ?", LABEL_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + _account_query_bind_text(hstmt, binding_count++, app_id); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + binding_count = 1; + ACCOUNT_MEMSET(query, 0, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE app_id = ? ", PROVIDER_FEATURE_TABLE); + + hstmt = _account_prepare_query(query); + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + _account_query_bind_text(hstmt, binding_count++, app_id); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found. AppId=%s, rc=%d\n", app_id, rc)); + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + is_success = TRUE; + + hstmt = NULL; + + binding_count = 1; + ACCOUNT_MEMSET(query, 0, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AppId = ? ", ACCOUNT_TYPE_TABLE); + + hstmt = _account_prepare_query(query); + ACCOUNT_CATCH_ERROR(hstmt != NULL, {}, ACCOUNT_ERROR_DB_FAILED, + ("_account_svc_query_prepare(%s) failed(%s).\n", query, _account_db_err_msg())); + + _account_query_bind_text(hstmt, binding_count++, app_id); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_DONE, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found. AppId=%s, rc=%d\n", app_id, rc)); + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + is_success = TRUE; + + hstmt = NULL; + + CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + ret_transaction = _account_end_transaction(is_success); + + if (ret_transaction != ACCOUNT_ERROR_NONE) { + ACCOUNT_ERROR("account_svc_delete:_account_svc_end_transaction fail %d, is_success=%d\n", ret_transaction, is_success); + } + + pthread_mutex_unlock(&account_mutex); + + return error_code; +} + +static void _account_type_convert_column_to_account_type(account_stmt hstmt, account_type_s *account_type_record) +{ + const char *textbuf = NULL; + + account_type_record->id = _account_query_table_column_int(hstmt, ACCOUNT_TYPE_FIELD_ID); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_TYPE_FIELD_APP_ID); + _account_db_data_to_text(textbuf, &(account_type_record->app_id)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_TYPE_FIELD_SERVICE_PROVIDER_ID); + _account_db_data_to_text(textbuf, &(account_type_record->service_provider_id)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_TYPE_FIELD_ICON_PATH); + _account_db_data_to_text(textbuf, &(account_type_record->icon_path)); + + textbuf = _account_query_table_column_text(hstmt, ACCOUNT_TYPE_FIELD_SMALL_ICON_PATH); + _account_db_data_to_text(textbuf, &(account_type_record->small_icon_path)); + + account_type_record->multiple_account_support = _account_query_table_column_int(hstmt, ACCOUNT_TYPE_FIELD_MULTIPLE_ACCOUNT_SUPPORT); + +} + +static void _account_type_convert_column_to_label(account_stmt hstmt, label_s *label_record) +{ + const char *textbuf = NULL; + + textbuf = _account_query_table_column_text(hstmt, LABEL_FIELD_APP_ID); + _account_db_data_to_text(textbuf, &(label_record->app_id)); + + textbuf = _account_query_table_column_text(hstmt, LABEL_FIELD_LABEL); + _account_db_data_to_text(textbuf, &(label_record->label)); + + textbuf = _account_query_table_column_text(hstmt, LABEL_FIELD_LOCALE); + _account_db_data_to_text(textbuf, &(label_record->locale)); + +} + +ACCOUNT_API int account_type_query_label_by_app_id(account_label_cb callback, const char* app_id, void *user_data ) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0, binding_count = 1; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((app_id != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", LABEL_TABLE); + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + _account_query_bind_text(hstmt, binding_count++, app_id); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + label_s* label_record = NULL; + + while (rc == SQLITE_ROW) { + bool cb_ret = FALSE; + label_record = (label_s*) malloc(sizeof(label_s)); + + if (label_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + + ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s)); + + _account_type_convert_column_to_label(hstmt, label_record); + + cb_ret = callback(label_record->app_id, label_record->label , label_record->locale, user_data); + + _account_type_free_label_items(label_record); + _ACCOUNT_FREE(label_record); + + ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n")); + + rc = _account_query_step(hstmt); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +int _account_type_label_get_app_id(label_h label, char **app_id) +{ + if (!label) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + if (!app_id) { + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + label_s *data = (label_s*)label; + + (*app_id) = NULL; + + *app_id = _account_get_text(data->app_id); + + return ACCOUNT_ERROR_NONE; +} + +bool _account_get_label_text_cb(char* app_id, char* label, char* locale, void *user_data) +{ + account_type_s *data = (account_type_s*)user_data; + + label_s *label_data = (label_s*)malloc(sizeof(label_s)); + + if (label_data == NULL) { + ACCOUNT_FATAL("_account_get_label_text_cb : MALLOC FAIL\n"); + return FALSE; + } + ACCOUNT_MEMSET(label_data, 0, sizeof(label_s)); + + label_data->app_id = _account_get_text(app_id); + label_data->label = _account_get_text(label); + label_data->locale = _account_get_text(locale); + + data->label_list = g_slist_append(data->label_list, (gpointer)label_data); + + return TRUE; +} + +bool _account_get_provider_feature_cb(char* app_id, char* key, void* user_data) +{ + account_type_s *data = (account_type_s*)user_data; + + provider_feature_s *feature_data = (provider_feature_s*)malloc(sizeof(provider_feature_s)); + + if (feature_data == NULL) { + ACCOUNT_FATAL("_account_get_provider_feature_cb : MALLOC FAIL\n"); + return FALSE; + } + ACCOUNT_MEMSET(feature_data, 0, sizeof(provider_feature_s)); + + feature_data->app_id = _account_get_text(app_id); + feature_data->key = _account_get_text(key); + + data->provider_feature_list = g_slist_append(data->provider_feature_list, (gpointer)feature_data); + + return TRUE; +} + +ACCOUNT_API int account_type_query_by_app_id(const char* app_id, account_type_h *account_type) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0, binding_count = 1; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((app_id != 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL")); + ACCOUNT_RETURN_VAL((*account_type != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT TYPE IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ?", ACCOUNT_TYPE_TABLE); + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + _account_query_bind_text(hstmt, binding_count++, app_id); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + account_type_s *account_type_record = (account_type_s *)(*account_type); + + while (rc == SQLITE_ROW) { + _account_type_convert_column_to_account_type(hstmt, account_type_record); + rc = _account_query_step(hstmt); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + account_type_query_label_by_app_id(_account_get_label_text_cb, app_id, (void*)account_type_record); + account_type_query_provider_feature_by_app_id(_account_get_provider_feature_cb, app_id,(void*)account_type_record); + + hstmt = NULL; + error_code = ACCOUNT_ERROR_NONE; + + CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +ACCOUNT_API int account_type_query_app_id_exist(const char* app_id) +{ + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((app_id != 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("APP ID IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) FROM %s WHERE AppId = '%s'", ACCOUNT_TYPE_TABLE, app_id); + rc = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (rc <= 0) { + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_type_query_by_provider_feature(account_type_cb callback, const char* key, void* user_data) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + GList *account_type_list = NULL; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((key != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("capability_type IS NULL")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("CALL BACK IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId IN (SELECT app_id from %s WHERE key=?)", ACCOUNT_TYPE_TABLE, PROVIDER_FEATURE_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + int binding_count = 1; + _account_query_bind_text(hstmt, binding_count++, key); + + rc = _account_query_step(hstmt); + + account_type_s *account_type_record = NULL; + + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + int k=0; + while(rc == SQLITE_ROW) { + account_type_record = (account_type_s*) malloc(sizeof(account_type_s)); + + if (account_type_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + + ACCOUNT_MEMSET(account_type_record, 0x00, sizeof(account_type_s)); + _account_type_convert_column_to_account_type(hstmt, account_type_record); + account_type_list = g_list_append(account_type_list, account_type_record); + rc = _account_query_step(hstmt); + k++; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {_account_type_glist_free(account_type_list);}, rc, ("finalize error")); + hstmt = NULL; + + GList* iter; + k = 0; + for (iter = account_type_list; iter != NULL; iter = g_list_next(iter)) { + account_type_s *account_type = NULL; + account_type = (account_type_s*)iter->data; + account_type_query_label_by_app_id(_account_get_label_text_cb,account_type->app_id,(void*)account_type); + account_type_query_provider_feature_by_app_id(_account_get_provider_feature_cb, account_type->app_id,(void*)account_type); + //cb_func((account_type_h)account_type, user_data); + ACCOUNT_CATCH_ERROR(callback((account_type_h)account_type, user_data) == TRUE, {}, ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n")); + k++; + } + + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + if (account_type_list) { + _account_type_glist_free(account_type_list); + account_type_list = NULL; + } + + return error_code; +} + + +ACCOUNT_API int account_type_foreach_account_type_from_db(account_type_cb callback, void *user_data) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + GList *account_type_list = NULL; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INFO IS NULL")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s ", ACCOUNT_TYPE_TABLE); + hstmt = _account_prepare_query(query); + + rc = _account_query_step(hstmt); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + account_type_s *account_type_record = NULL; + + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + int k=0; + while(rc == SQLITE_ROW) { + account_type_record = (account_type_s*) malloc(sizeof(account_type_s)); + + if (account_type_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + + ACCOUNT_MEMSET(account_type_record, 0x00, sizeof(account_type_s)); + _account_type_convert_column_to_account_type(hstmt, account_type_record); + account_type_list = g_list_append(account_type_list, account_type_record); + rc = _account_query_step(hstmt); + k++; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {_account_type_glist_free(account_type_list);}, rc, ("finalize error")); + hstmt = NULL; + + GList* iter; + k = 0; + for (iter = account_type_list; iter != NULL; iter = g_list_next(iter)) { + account_type_s *account_type = NULL; + account_type = (account_type_s*)iter->data; + account_type_query_label_by_app_id(_account_get_label_text_cb,account_type->app_id,(void*)account_type); + account_type_query_provider_feature_by_app_id(_account_get_provider_feature_cb, account_type->app_id,(void*)account_type); + callback((account_type_h)account_type, user_data); + k++; + } + + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + if (account_type_list) { + _account_type_glist_free(account_type_list); + account_type_list = NULL; + } + + return error_code; +} + +// output parameter label must be free +ACCOUNT_API int account_type_query_label_by_locale(const char* app_id, const char* locale, char** label) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0, binding_count = 1; + + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + char* converted_locale = NULL; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((app_id != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("NO APP ID")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + ACCOUNT_RETURN_VAL((label != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("label char is null")); + ACCOUNT_RETURN_VAL((locale != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("locale char is null")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + converted_locale = _account_get_text(locale); + gchar** tokens = g_strsplit(converted_locale, "-", 2); + + if(tokens != NULL) { + if((char*)(tokens[1]) != NULL) { + char* upper_token = g_ascii_strup(tokens[1], strlen(tokens[1])); + if(upper_token != NULL) { + _ACCOUNT_FREE(converted_locale); + converted_locale = g_strdup_printf("%s_%s", tokens[0], upper_token); + } + _ACCOUNT_FREE(upper_token); + } + } + g_strfreev(tokens); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AppId = ? AND Locale = '%s' ", LABEL_TABLE, converted_locale); + _ACCOUNT_FREE(converted_locale); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + _account_query_bind_text(hstmt, binding_count++, app_id); + + rc = _account_query_step(hstmt); + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + label_s* label_record = NULL; + + while (rc == SQLITE_ROW) { + label_record = (label_s*) malloc(sizeof(label_s)); + + if (label_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + + ACCOUNT_MEMSET(label_record, 0x00, sizeof(label_s)); + + _account_type_convert_column_to_label(hstmt,label_record); + + _ACCOUNT_FREE(*label); + *label = _account_get_text(label_record->label); + + _account_type_free_label_items(label_record); + _ACCOUNT_FREE(label_record); + + rc = _account_query_step(hstmt); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + error_code = ACCOUNT_ERROR_NONE; + + CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +static int _account_insert_custom(account_s *account, int account_id) +{ + int rc, count = 1; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + account_stmt hstmt = NULL; + + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + + if (g_slist_length( account->custom_list)==0) { + ACCOUNT_DEBUG( "_account_insert_custom, no custom data\n"); + return ACCOUNT_ERROR_NONE; + } + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_id); + + rc = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%d, %s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + if (rc <= 0) { + ACCOUNT_SLOGE( "_account_insert_custom : related account item is not existed rc=%d , %s", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + /* insert query*/ + + GSList *iter; + + for (iter = account->custom_list; iter != NULL; iter = g_slist_next(iter)) { + int ret; + count = 1; + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s (AccountId, AppId, Key, Value) VALUES " + "(?, ?, ?, ?) ", ACCOUNT_CUSTOM_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg())); + + account_custom_s* custom_data = NULL; + custom_data = (account_custom_s*)iter->data; + + ret = _account_query_bind_int(hstmt, count++, account_id); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Int binding fail")); + ret = _account_query_bind_text(hstmt, count++, account->package_name); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->key); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->value); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + break; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + } + + return ACCOUNT_ERROR_NONE; +} + +static int _account_update_custom(account_s *account, int account_id) +{ + int rc, count = 1; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + account_stmt hstmt = NULL; + + ACCOUNT_RETURN_VAL((account != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT HANDLE IS NULL")); + + if (g_slist_length( account->custom_list)==0) { + ACCOUNT_DEBUG( "_account_update_custom, no custom data\n"); + return ACCOUNT_ERROR_NONE; + } + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT COUNT(*) from %s where _id=%d", ACCOUNT_TABLE, account_id); + + rc = _account_get_record_count(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } else if( _account_db_err_code() == SQLITE_BUSY ){ + ACCOUNT_ERROR( "database busy(%s)", _account_db_err_msg()); + pthread_mutex_unlock(&account_mutex); + return ACCOUNT_ERROR_DATABASE_BUSY; + } + + if (rc <= 0) { + ACCOUNT_SLOGE( "_account_update_custom : related account item is not existed rc=%d , %s", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_RECORD_NOT_FOUND; + } + + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + + ACCOUNT_SNPRINTF(query, sizeof(query), "DELETE FROM %s WHERE AccountId=? ", ACCOUNT_CUSTOM_TABLE); + hstmt = _account_prepare_query(query); + count = 1; + _account_query_bind_int(hstmt, count++, (int)account_id); + rc = _account_query_step(hstmt); + + if (rc == SQLITE_BUSY) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_DATABASE_BUSY; + } else if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + return ACCOUNT_ERROR_DB_FAILED; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + GSList *iter; + + for (iter = account->custom_list; iter != NULL; iter = g_slist_next(iter)) { + int ret; + count = 1; + ACCOUNT_MEMSET(query, 0x00, sizeof(query)); + ACCOUNT_SNPRINTF(query, sizeof(query), "INSERT INTO %s(AccountId, AppId, Key, Value) VALUES " + "(?, ?, ?, ?) ", ACCOUNT_CUSTOM_TABLE); + + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + ACCOUNT_RETURN_VAL((hstmt != NULL), {}, ACCOUNT_ERROR_DB_FAILED, ("_account_prepare_query() failed(%s).\n", _account_db_err_msg())); + + account_custom_s* custom_data = NULL; + custom_data = (account_custom_s*)iter->data; + + ret = _account_query_bind_int(hstmt, count++, (int)account_id); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Int binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)account->package_name); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->key); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + ret = _account_query_bind_text(hstmt, count++, (char*)custom_data->value); + ACCOUNT_RETURN_VAL((ret == ACCOUNT_ERROR_NONE), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("Text binding fail")); + + rc = _account_query_step(hstmt); + + if (rc != SQLITE_DONE) { + ACCOUNT_ERROR( "_account_query_step() failed(%d, %s)", rc, _account_db_err_msg()); + break; + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + } + + return ACCOUNT_ERROR_NONE; +} + +static int _account_query_custom_by_account_id(account_custom_cb callback, int account_id, void *user_data ) +{ + int error_code = ACCOUNT_ERROR_NONE; + account_stmt hstmt = NULL; + char query[ACCOUNT_SQL_LEN_MAX] = {0, }; + int rc = 0; + + ACCOUNT_RETURN_VAL((account_id > 0), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("ACCOUNT INDEX IS LESS THAN 0")); + ACCOUNT_RETURN_VAL((callback != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("NO CALLBACK FUNCTION")); + ACCOUNT_RETURN_VAL((g_hAccountDB != NULL), {}, ACCOUNT_ERROR_DB_NOT_OPENED, ("The database isn't connected.")); + + ACCOUNT_MEMSET(query, 0x00, ACCOUNT_SQL_LEN_MAX); + + ACCOUNT_SNPRINTF(query, sizeof(query), "SELECT * FROM %s WHERE AccountId = %d", ACCOUNT_CUSTOM_TABLE, account_id); + hstmt = _account_prepare_query(query); + + if( _account_db_err_code() == SQLITE_PERM ){ + ACCOUNT_ERROR( "Access failed(%s)", _account_db_err_msg()); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + rc = _account_query_step(hstmt); + + ACCOUNT_CATCH_ERROR(rc == SQLITE_ROW, {}, ACCOUNT_ERROR_RECORD_NOT_FOUND, ("The record isn't found.\n")); + + account_custom_s* custom_record = NULL; + + while (rc == SQLITE_ROW) { + bool cb_ret = FALSE; + custom_record = (account_custom_s*) malloc(sizeof(account_custom_s)); + + if (custom_record == NULL) { + ACCOUNT_FATAL("malloc Failed"); + break; + } + + ACCOUNT_MEMSET(custom_record, 0x00, sizeof(account_custom_s)); + + _account_convert_column_to_custom(hstmt, custom_record); + + cb_ret = callback(custom_record->key, custom_record->value, user_data); + + _account_custom_item_free(custom_record); + _ACCOUNT_FREE(custom_record); + + ACCOUNT_CATCH_ERROR(cb_ret == TRUE, {}, ACCOUNT_ERROR_NONE, ("Callback func returs FALSE, its iteration is stopped!!!!\n")); + + rc = _account_query_step(hstmt); + } + + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + + error_code = ACCOUNT_ERROR_NONE; + +CATCH: + if (hstmt != NULL) { + rc = _account_query_finalize(hstmt); + ACCOUNT_RETURN_VAL((rc == ACCOUNT_ERROR_NONE), {}, rc, ("finalize error")); + hstmt = NULL; + } + + pthread_mutex_unlock(&account_mutex); + return error_code; +} + +static void _account_subscribe_vconf_callback(keynode_t *key, void *user_data) +{ + account_subscribe_s* tmp = (account_subscribe_s*)user_data; + char *msg = NULL, *vconf_key = NULL; + char *key_name = NULL; + char event_msg[256] ={0, }; + int account_id = -1; + + if(!key) { + ACCOUNT_ERROR("No subscribtion msg !!!!!\n"); + return; + } + + if(!tmp) { + ACCOUNT_ERROR("user data required\n"); + return; + } + + key_name = vconf_keynode_get_name(key); + if( key_name == NULL ) { + ACCOUNT_ERROR("vconf_keynode_get_name(key) fail\n"); + return; + } + + if(!memcmp(key_name, VCONFKEY_ACCOUNT_MSG_STR, strlen(VCONFKEY_ACCOUNT_MSG_STR))) + { + vconf_key = vconf_keynode_get_str(key); + + if( vconf_key == NULL){ + ACCOUNT_ERROR("vconf key is NULL.\n"); + return; + } + msg = strdup(vconf_key); + + char* event_type = NULL; + char* id = NULL; + char* ptr = NULL; + + event_type = strtok_r(msg, ":", &ptr); + id = strtok_r(NULL, ":", &ptr); + + ACCOUNT_SLOGD("msg(%s), event_type(%s), id(%s)", msg, event_type, id); + + ACCOUNT_SNPRINTF(event_msg,sizeof(event_msg),"%s", event_type); + + account_id = atoi(id); + + if(tmp->account_subscription_callback) + tmp->account_subscription_callback(event_msg, account_id, tmp->user_data); + } + + _ACCOUNT_FREE(msg); + +} + +static void _account_subscribe_vconf_callback_ex(keynode_t *key, void *user_data) +{ + account_subscribe_s* tmp = (account_subscribe_s*)user_data; + char *msg = NULL, *vconf_key = NULL; + char *key_name = NULL; + char event_msg[256] ={0, }; + int account_id = -1; + + if(!key) { + ACCOUNT_ERROR("No subscribtion msg !!!!!\n"); + return; + } + + if(!tmp) { + ACCOUNT_ERROR("user data required\n"); + return; + } + + key_name = vconf_keynode_get_name(key); + if( key_name == NULL ) { + ACCOUNT_ERROR("vconf_keynode_get_name(key) fail\n"); + return; + } + + if(!memcmp(key_name, VCONFKEY_ACCOUNT_MSG_STR, strlen(VCONFKEY_ACCOUNT_MSG_STR))) + { + vconf_key = vconf_keynode_get_str(key); + + if( vconf_key == NULL){ + ACCOUNT_ERROR("vconf key is NULL.\n"); + return; + } + msg = strdup(vconf_key); + + char* event_type = NULL; + char* id = NULL; + char* ptr = NULL; + event_type = strtok_r(msg, ":", &ptr); + id = strtok_r(NULL, ":", &ptr); + ACCOUNT_SLOGD("msg(%s), event_type(%s), id(%s)", msg, event_type, id); + + ACCOUNT_SNPRINTF(event_msg,sizeof(event_msg),"%s", event_type); + account_id = atoi(id); + + if(tmp->account_subscription_callback) + tmp->account_subscription_callback(event_msg, account_id, tmp->user_data); + } + + _ACCOUNT_FREE(msg); +} + +ACCOUNT_API int account_subscribe_create(account_subscribe_h* account_subscribe) +{ + if (!account_subscribe) { + ACCOUNT_SLOGE("account is NULL.\n", __FUNCTION__, __LINE__); + return ACCOUNT_ERROR_INVALID_PARAMETER; + } + + account_subscribe_s *data = (account_subscribe_s*)calloc(1,sizeof(account_subscribe_s)); + + if(!data) { + ACCOUNT_FATAL("OUT OF MEMORY\n"); + return ACCOUNT_ERROR_OUT_OF_MEMORY; + } + + *account_subscribe = (account_subscribe_h)data; + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_subscribe_notification(account_subscribe_h account_subscribe, account_event_cb callback, void* user_data) +{ + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((account_subscribe != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("(%s)-(%d) account subscribe handle is NULL.\n", __FUNCTION__, __LINE__)); + + account_subscribe_s* tmp =(account_subscribe_s*)account_subscribe; + + tmp->account_subscription_callback = callback; + tmp->user_data = user_data; + + int ret = -1; + ret = vconf_notify_key_changed(VCONFKEY_ACCOUNT_MSG_STR, + (vconf_callback_fn)_account_subscribe_vconf_callback, + (void*)tmp); + + ACCOUNT_SLOGI("vconf_notify_key_changed ret = %d", ret); + + if(ret != VCONF_OK) { + ACCOUNT_ERROR("Vconf Subscription Failed ret = %d", ret); + return ACCOUNT_ERROR_EVENT_SUBSCRIPTION_FAIL; + } + + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_API int account_unsubscribe_notification(account_subscribe_h account_subscribe) +{ + int res; + int process_uid = getuid(); + char subject_label[SMACK_LABEL_LEN + 1] = {0,}; + + if(process_uid != 0) { + int fd = open("/proc/self/attr/current", O_RDONLY); + if(fd < 0) + { + ACCOUNT_ERROR("file open fail :: /proc/self/attr/current"); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = read(fd, subject_label, SMACK_LABEL_LEN); + if(res < 0) + { + ACCOUNT_ERROR("file read fail :: /proc/self/attr/current"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + + res = smack_have_access(subject_label, "libaccounts-svc::check_read", "r"); + if(res != 1) { + ACCOUNT_ERROR("Account permission denied :: This API can not be used without account.read privilege"); + close(fd); + return ACCOUNT_ERROR_PERMISSION_DENIED; + } + close(fd); + } + + ACCOUNT_RETURN_VAL((account_subscribe != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("(%s)-(%d) account subscribe handle is NULL.\n", __FUNCTION__, __LINE__)); + + account_subscribe_s* tmp =(account_subscribe_s*)account_subscribe; + + _ACCOUNT_FREE(tmp); + + if (vconf_ignore_key_changed(VCONFKEY_ACCOUNT_MSG_STR, + (vconf_callback_fn)_account_subscribe_vconf_callback) != 0) { + ACCOUNT_ERROR("Vconf Subscription Failed !!!!!\n"); + return ACCOUNT_ERROR_EVENT_SUBSCRIPTION_FAIL; + } + + return ACCOUNT_ERROR_NONE; +} + + +ACCOUNT_INTERNAL_API int account_subscribe_notification_ex(account_subscribe_h account_subscribe, account_event_cb callback, void* user_data) +{ + ACCOUNT_RETURN_VAL((account_subscribe != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("(%s)-(%d) account subscribe handle is NULL.\n", __FUNCTION__, __LINE__)); + + account_subscribe_s* tmp =(account_subscribe_s*)account_subscribe; + tmp->account_subscription_callback = callback; + tmp->user_data = user_data; + + int ret = -1; + ret = vconf_notify_key_changed(VCONFKEY_ACCOUNT_MSG_STR, + (vconf_callback_fn)_account_subscribe_vconf_callback_ex, + (void*)tmp); + ACCOUNT_SLOGI("vconf_notify_key_changed ret = %d", ret); + + if(ret != VCONF_OK) { + ACCOUNT_ERROR("Vconf Subscription Failed ret = %d", ret); + return ACCOUNT_ERROR_EVENT_SUBSCRIPTION_FAIL; + } + return ACCOUNT_ERROR_NONE; +} + +ACCOUNT_INTERNAL_API int account_unsubscribe_notification_ex(account_subscribe_h account_subscribe) +{ + ACCOUNT_RETURN_VAL((account_subscribe != NULL), {}, ACCOUNT_ERROR_INVALID_PARAMETER, ("(%s)-(%d) account subscribe handle is NULL.\n", __FUNCTION__, __LINE__)); + account_subscribe_s* tmp =(account_subscribe_s*)account_subscribe; + + _ACCOUNT_FREE(tmp); + + if (vconf_ignore_key_changed(VCONFKEY_ACCOUNT_MSG_STR, + (vconf_callback_fn)_account_subscribe_vconf_callback_ex) != 0) { + ACCOUNT_ERROR("Vconf Subscription Failed !!!!!\n"); + return ACCOUNT_ERROR_EVENT_SUBSCRIPTION_FAIL; + } + + return ACCOUNT_ERROR_NONE; +} diff --git a/src/utc-account.c b/src/utc-account.c new file mode 100755 index 0000000..85de29c --- /dev/null +++ b/src/utc-account.c @@ -0,0 +1,8276 @@ +/* + * utc-account + * + * Copyright (c) 2012 - 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Wonyoung Lee <wy1115.lee@samsung.com>, Sungchan Kim <sungchan81.kim@samsung.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include <stdio.h> +#include "account.h" +#include "account-private.h" +#include <string.h> +//#include <dbus/dbus.h> + +int account_id = 0; + +static void _account_free_text(char *text) +{ + if (text) { + free(text); + text = NULL; + } +} + +bool _capability_get_callback(const char* capability_type, account_capability_state_e capability_value, void* user_data) +{ + char* test_type = (char*)capability_type; + int test_value = capability_value; + + ACCOUNT_SLOGD("_capability_get_callback test_type = : %s\n", test_type); + ACCOUNT_SLOGD("_capability_get_callback test_value = : %d\n", test_value); + return TRUE; +} + +int _account_get_account_info(account_h handle) +{ + ACCOUNT_SLOGD("_account_get_callback\n"); + + char *test_text = NULL; + + account_get_user_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_display_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_email_address(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_icon_path(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_source(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_package_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_domain_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_access_token(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + _account_free_text(test_text); + + account_get_user_text(handle, i, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + } + + int test_int = -1; + + account_auth_type_e auth_type; + account_get_auth_type(handle, &auth_type); + ACCOUNT_SLOGD("account_get_auth_type : %d\n", auth_type); + + account_secrecy_state_e secret; + account_get_secret(handle, &secret); + ACCOUNT_SLOGD("account_get_secret : %d\n", secret); + + account_sync_state_e sync_support; + account_get_sync_support(handle, &sync_support); + ACCOUNT_SLOGD("account_get_sync_support : %d\n", sync_support); + + for(i=0;i<USER_INT_CNT;i++) + { + test_int = -1; + account_get_user_int(handle, i, &test_int); + ACCOUNT_SLOGD("_account_get_callback : %d\n", test_int); + } + + account_get_capability_all(handle, _capability_get_callback, NULL); + + return 0; +} + + +bool _account_get_callback(account_h handle, void* user_data) +{ + ACCOUNT_SLOGD("_account_get_callback\n"); + + char *test_text = NULL; + + account_get_user_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_display_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_email_address(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_icon_path(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_source(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_package_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_domain_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_access_token(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + _account_free_text(test_text); + + account_get_user_text(handle, i, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + } + + int test_int = -1; + + account_auth_type_e auth_type; + account_get_auth_type(handle, &auth_type); + ACCOUNT_SLOGD("account_get_auth_type : %d\n", auth_type); + + account_secrecy_state_e secret; + account_get_secret(handle, &secret); + ACCOUNT_SLOGD("account_get_secret : %d\n", secret); + + account_sync_state_e sync_support; + account_get_sync_support(handle, &sync_support); + ACCOUNT_SLOGD("account_get_sync_support : %d\n", sync_support); + + for(i=0;i<USER_INT_CNT;i++) + { + test_int = -1; + account_get_user_int(handle, i, &test_int); + ACCOUNT_SLOGD("_account_get_callback : %d\n", test_int); + } + + account_get_capability_all(handle, _capability_get_callback, NULL); + + return TRUE; +} + +static int _account_insert_test_new(void) +{ + int ret = -1; + + account_h account = NULL; + int temp_int = -1; + + ret = account_connect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + char temp[128]; + memset(temp, 0x00, sizeof(temp)); + + ret = account_create(&account); + ACCOUNT_SLOGD("account_set_user_name: Enter User Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_user_name(account, temp); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + ACCOUNT_SLOGD("account_set_display_name: Enter display Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_display_name(account, temp); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + ACCOUNT_SLOGD("account_set_domain_name: Enter domain Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_domain_name(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + memset(temp, 0x00, sizeof(temp)); + ACCOUNT_SLOGD("account_set_email_address: Enter email Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_email_address(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + ACCOUNT_SLOGD("account_set_package_name: Enter package Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_package_name(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + ACCOUNT_SLOGD("account_set_icon_path: Enter icon path to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_icon_path(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_access_token: Enter access token to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_access_token(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + ACCOUNT_SLOGD("account_set_auth_type: Enter auth type to be set \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_auth_type( account, temp_int ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + temp_int = -1; + ACCOUNT_SLOGD("account_set_secret: Enter secret to be set \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_secret( account, temp_int ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + temp_int = -1; + ACCOUNT_SLOGD("account_set_sync_support: Enter sync support state \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_sync_support( account, temp_int ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + memset(temp, 0x00, sizeof(temp)); + ACCOUNT_SLOGD("account_set_source: Enter source to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_source(account, temp); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + memset(temp, 0x00, sizeof(temp)); + ACCOUNT_SLOGD("account_set_user_text [%d]: Enter user text to be set \n", i); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_user_text(account, i, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + for(i=0;i<USER_INT_CNT;i++) + { + temp_int = -1; + ACCOUNT_SLOGD("account_set_user_int [%d]: Enter user int to be set \n", i); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_user_int(account, i, temp_int); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + int cap_key = -1; + int cap_value = -1; + int want_to_enter_more_cap = 1; + while (want_to_enter_more_cap){ + ACCOUNT_SLOGD("account_set_capability: Enter capability key to set \n"); + if (scanf("%d", &cap_key) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + ACCOUNT_SLOGD("account_set_capability: Enter capability value to set \n"); + if (scanf("%d", &cap_value) != 1 ) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_TIZEN_EMAIL, cap_value); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ACCOUNT_SLOGD("account_set_capability: Want to set more capabilitiy key value then enter 1 else 0 \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + if (temp_int == 1) + want_to_enter_more_cap = 1; + else + want_to_enter_more_cap = 0; + } + int account_id = -1; + ret = account_insert_to_db(account, &account_id); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return -1; + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return account_id; +} + +#if 0 +static int _account_insert_test(void) +{ + int ret = -1; + + account_h account = NULL; + + ACCOUNT_SLOGD("account_connect returns %d\n", ret); + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p\n", account); + + ret = account_set_user_name(account, "wy1115.lee"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "Wonyoung Lee"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung electronics"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "URUSA inc."); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 888); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + ret = account_set_capability(account, ACCOUNT_CAPABILITY_CONTACT, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_CALENDAR, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_VIDEO, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_EMAIL, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_STATUS_POST, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_VOIP, ACCOUNT_CAPABILITY_ENABLED); + //ret = account_set_capability(account, ACCOUNT_CAPABILITY_IM, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_SAMSUNG_APPS, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_MOBILE_TRACKER, ACCOUNT_CAPABILITY_ENABLED); + + int account_id = -1; + ret = account_insert_to_db(account, &account_id); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + return -1; + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account=NULL; + + ACCOUNT_SLOGD("account_connect returns %d\n", ret); + + ret = account_create(&account); + + account_query_account_by_account_id(account_id, &account); + _account_get_account_info(account); + + account_query_capability_by_account_id(_capability_get_callback, account_id, NULL); + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + + account=NULL; + + ACCOUNT_SLOGD("account_connect returns %d\n", ret); + + ret = account_create(&account); + + account_query_account_by_user_name(_account_get_callback, "usernamed-wy1115", NULL); + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + return account_id; +} +#endif + +static int _account_update_test_new_by_user_name(char *user_name, char *package_name) +{ + int ret = -1; + + account_h account = NULL; + int temp_int = -1; + + char temp[128]; + memset(temp, 0x00, sizeof(temp)); + ret = account_connect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_create(&account); + ACCOUNT_SLOGD("account_set_user_name: Enter User Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_user_name(account, temp); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_display_name: Enter display Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_display_name(account, temp); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_domain_name: Enter domain Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_domain_name(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_email_address: Enter email Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_email_address(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_package_name: Enter package Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_package_name(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_icon_path: Enter icon path to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_icon_path(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_access_token: Enter access token to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_access_token(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_auth_type: Enter auth type to be set \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_auth_type( account, temp_int ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + temp_int = -1; + ACCOUNT_SLOGD("account_set_secret: Enter secret to be set \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_secret( account, temp_int ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + temp_int = -1; + ACCOUNT_SLOGD("account_set_sync_support: Enter sync support state \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_sync_support( account, temp_int ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_source: Enter source to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_source(account, temp); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_user_text [%d]: Enter user text to be set \n", i); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_user_text(account, i, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + for(i=0;i<USER_INT_CNT;i++) + { + temp_int = -1; + ACCOUNT_SLOGD("account_set_user_int [%d]: Enter user int to be set \n", i); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_user_int(account, i, temp_int); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + int cap_key = -1; + int cap_value = -1; + int want_to_enter_more_cap = 1; + while (want_to_enter_more_cap){ + ACCOUNT_SLOGD("account_set_capability: Enter capability key to set \n"); + if (scanf("%d", &cap_key) != 1 ) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + ACCOUNT_SLOGD("account_set_capability: Enter capability value to set \n"); + if (scanf("%d", &cap_value) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_TIZEN_EMAIL, cap_value); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ACCOUNT_SLOGD("account_set_capability: Want to set more capabilitiy key value then enter 1 else 0 \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + if (temp_int == 1) + want_to_enter_more_cap = 1; + else + want_to_enter_more_cap = 0; + } + + + ret = account_update_to_db_by_user_name(account, user_name, package_name); + + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + return ret; + +} + + +static int _account_update_test_new(int account_id) +{ + + int ret = -1; + + account_h account = NULL; + int temp_int = -1; + + char temp[128]; + memset(temp, 0x00, sizeof(temp)); + ret = account_connect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + + ret = account_create(&account); + ACCOUNT_SLOGD("account_set_user_name: Enter User Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_user_name(account, temp); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_display_name: Enter display Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_display_name(account, temp); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + ACCOUNT_SLOGD("account_set_domain_name: Enter domain Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_domain_name(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + memset(temp, 0x00, sizeof(temp)); + ACCOUNT_SLOGD("account_set_email_address: Enter email Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_email_address(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_package_name: Enter package Name to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_package_name(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_icon_path: Enter icon path to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_icon_path(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_access_token: Enter access token to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_access_token(account, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_auth_type: Enter auth type to be set \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_auth_type( account, temp_int ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + temp_int = -1; + ACCOUNT_SLOGD("account_set_secret: Enter secret to be set \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_secret( account, temp_int ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + temp_int = -1; + ACCOUNT_SLOGD("account_set_sync_support: Enter sync support state \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + + ret = account_set_sync_support( account, temp_int ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_source: Enter source to be set \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_source(account, temp); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("account_set_user_text [%d]: Enter user text to be set \n", i); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_user_text(account, i, temp); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + for(i=0;i<USER_INT_CNT;i++) + { + temp_int = -1; + ACCOUNT_SLOGD("account_set_user_int [%d]: Enter user int to be set \n", i); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + ret = account_set_user_int(account, i, temp_int); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + int cap_key = -1; + int cap_value = -1; + int want_to_enter_more_cap = 1; + while (want_to_enter_more_cap){ + ACCOUNT_SLOGD("account_set_capability: Enter capability key to set \n"); + if (scanf("%d", &cap_key) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + ACCOUNT_SLOGD("account_set_capability: Enter capability value to set \n"); + if (scanf("%d", &cap_value) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_TIZEN_EMAIL, cap_value); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ACCOUNT_SLOGD("account_set_capability: Want to set more capabilitiy key value then enter 1 else 0 \n"); + if (scanf("%d", &temp_int) != 1) { + ACCOUNT_SLOGD("scanf Failed !!!! \n"); + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + return ret; + } + if (temp_int == 1) + want_to_enter_more_cap = 1; + else + want_to_enter_more_cap = 0; + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + return ret; +} + +#if 0 +static int _account_update_test(int account_id) +{ + int ret = - 1; + + account_h account = NULL; + + ret = account_create(&account); + + ret = account_set_user_name(account, "updated-wy1115"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "updated-Wonyoung Lee"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "updated-URUSA inc."); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "updated-user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 111); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + + ret = account_set_capability(account, ACCOUNT_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_VIDEO, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_STATUS_POST, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_SAMSUNG_APPS, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_MOBILE_TRACKER, ACCOUNT_CAPABILITY_ENABLED); + + ret = account_update_to_db_by_id(account, account_id); + + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + return ret; + +} + +static int _account_update_test_by_username() +{ + int ret = - 1; + + account_h account = NULL; + + ret = account_create(&account); + + ret = account_set_user_name(account, "usernamed-wy1115"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "usernamed-Wonyoung Lee"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "usernamed-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "usernamed-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "usernamed-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "usernamed-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "usernamed-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "updated-URUSA inc."); + + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "usernamed-user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 111); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + + ret = account_set_capability(account, ACCOUNT_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_VIDEO, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_VOIP, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_SAMSUNG_APPS, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_CAPABILITY_STATUS_POST, ACCOUNT_CAPABILITY_ENABLED); + + ret = account_update_to_db_by_user_name(account, "updated-wy1115", "updated-com.samsung.account"); + + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + return ret; + +} + +static int _account_test_capability() +{ + GSList* list = NULL; + GSList* iter = NULL; + int glist_len = 0; + + list = g_slist_append(list, strdup("test 1")); + list = g_slist_append(list, strdup("test 2")); + list = g_slist_append(list, strdup("test 3")); + list = g_slist_append(list, strdup("test 4")); + list = g_slist_append(list, strdup("test 5")); + list = g_slist_append(list, strdup("test 6")); + + glist_len = g_slist_length( list ); + + int capability_count = g_slist_length( list ); + + int binding_bufsize = 2+2*(capability_count*2)+1; + + int binding_buf_index = 0; + char* binding_buf = (char*)malloc(sizeof(char)*binding_bufsize); + + memset(binding_buf, 0, sizeof(char)*binding_bufsize); + + binding_buf[binding_buf_index++]='('; + + ACCOUNT_SLOGD("(%d)Binding buf = %s\n", __LINE__,binding_buf); + + int i; + + for(i=0;i<capability_count;i++) + { + /*snprintf(binding_buf+binding_buf_index, strlen(binding_buf)+2, "%s?,", binding_buf);*/ + binding_buf[binding_buf_index++]='?'; + if(i != capability_count -1) + binding_buf[binding_buf_index++]=','; + ACCOUNT_SLOGD("(%d)Binding buf = %s\n", __LINE__,binding_buf); + } + + binding_buf[binding_buf_index]=')'; + + ACCOUNT_SLOGD("(%d)Binding buf = %s\n", __LINE__,binding_buf); + + ACCOUNT_SLOGD("Length %d\n", glist_len); + + for (iter = list; iter != NULL; iter = g_slist_next(iter)) + { + char* capa; + capa = (char *)iter->data; + ACCOUNT_SLOGD("%s\n", (char *)iter->data); + g_free(capa); + } + + + g_slist_free(list); + g_free(binding_buf); + return 0; +} +#endif + +static int utc1_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc2_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + + + + +static int utc3_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "11111111111111111111111111111111111 \ + 2222222222222222222222222222222222222222222222222 \ + 3333333333333333333333333333333333333333333333333\ + 4444444444444444444444444444444444444444444444444\ + 5555555555555555555555555555555555555555555555555\ + 666666666666666666666666666666666666666666666666\ + 777777777777777777777777777777777777777777777777\ + 888888888888888888888888888888888888888888888888\ + 99999999999999999999999999999999999999999999999\ + 111111111111111111111111111111111111111111111111\ + 22222222222222222222222222222222222222222222222\ + 333333333333333333333333333333333333333333333\ + 444444444444444444444444444444444444444444\ + 444444444444444444444444444444444444444444444444\ + 555555555555555555555555555555555555555555555555 \ + 66666666666666666666666666666666666666666666666666\ + 777777777777777777777777777777777777777777777777779999999999999999999999999999999999999999\ + 999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999\ + 999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc4_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, NULL); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc5_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc6_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc7_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc8_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc9_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc10_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc11_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, NULL); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc12_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc13_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc14_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "xxxx/yyyy/zzzz/-&abc"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc15_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "xxxx/yyyy/zzzz/-&abc"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc16_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "xxxx/yyyy/zzzz/-&abc"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc17_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "xxxx/yyyy/zzzz/-&abc"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_source(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc18_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "xxxx/yyyy/zzzz/-&abc"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_source(account, "URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc19_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "xxxx/yyyy/zzzz/-&abc"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_source(account, "URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + int i; + + for(i=0; i<USER_TXT_CNT; i++) + { + ret = account_set_user_text(account, i, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc20_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "xxxx/yyyy/zzzz/-&abc"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_source(account, "URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + + int i; + + for(i=0; i<USER_TXT_CNT; i++) + { + ret = account_set_user_text(account, i, "user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc21_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "xxxx/yyyy/zzzz/-&abc"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_source(account, "URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + int i; + + for(i=0; i<USER_TXT_CNT; i++) + { + ret = account_set_user_text(account, i, "user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 000); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc22_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "xxxx/yyyy/zzzz/-&abc"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_source(account, "URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + int i; + + for(i=0; i<USER_TXT_CNT; i++) + { + ret = account_set_user_text(account, i, "user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 888); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return account_id; +} + +static int utc23_account_insert() +{ + + int ret = -1; + account_h account = NULL; + int account_id = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + ACCOUNT_SLOGD("account = %p, ret = %d \n", account, ret); + + ret = account_set_user_name(account, "tarun.kr"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_display_name(account, "tarun kumar"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_domain_name(account, "Samsung"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_email_address(account, "tarun.kr@samsung.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_package_name(account, "com.samsung.accounts"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_icon_path(account, "/test/test.jpg"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_access_token(account, "xxxx/yyyy/zzzz/-&abc"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_set_source(account, "URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + int i; + + for(i=0; i<USER_TXT_CNT; i++) + { + ret = account_set_user_text(account, i, "user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 888); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_CONTACT, ACCOUNT_CAPABILITY_ENABLED); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_POST, ACCOUNT_CAPABILITY_ENABLED); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_insert_to_db(account, &account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p , account_id = %d\n", __LINE__, ret, account, account_id); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return account_id; +} + +static int utc1_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, 0); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc2_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, -999); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc3_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, 555); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc4_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, NULL); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc5_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc6_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc7_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc8_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} +static int utc9_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc10_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc11_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc12_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc13_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc14_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc15_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc16_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc17_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc18_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_auth_type( account, ACCOUNT_AUTH_TYPE_OAUTH ); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_secret( account, ACCOUNT_SECRECY_INVISIBLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc19_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc20_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "updated-URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc21_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "updated-URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + int i; + + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, NULL); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc22_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "updated-URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + int i; + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "updated-user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc23_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "updated-URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + int i; + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "updated-user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, -111); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc24_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "updated-URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + int i; + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "updated-user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 0); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc25_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "updated-URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + int i; + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "updated-user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 111); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc26_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "updated-URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + int i; + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "updated-user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 111); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc27_account_update() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + account_set_user_name(account, "updated-tarun.kr"); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_display_name(account, "updated-tarun kumar"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_domain_name(account, "updated-Samsung Facebook"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_email_address(account, "updated-urusa77@gmail.com"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_package_name(account, "updated-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_icon_path(account, "updated-icon-path"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_access_token(account, "updated-ACCESSTOKEN"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_set_source(account, "updated-URUSA inc."); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + int i; + for(i=0;i<USER_TXT_CNT;i++) + { + ret = account_set_user_text(account, i, "updated-user txt"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + + } + for(i=0;i<USER_INT_CNT;i++) + { + ret = account_set_user_int(account, i, 111); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p, i=%d\n", __LINE__, ret, account, i); + } + } + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_CONTACT, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_CALENDAR, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_VIDEO, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_EMAIL, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_POST, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_VOIP, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_SAMSUNG_APPS, ACCOUNT_CAPABILITY_ENABLED); + ret = account_set_capability(account, ACCOUNT_SUPPORTS_CAPABILITY_MOBILE_TRACKER, ACCOUNT_CAPABILITY_ENABLED); + + ret = account_update_to_db_by_id(account, account_id); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +bool _utc1_account_get_callback(account_h handle, void* user_data) +{ + ACCOUNT_SLOGD("_account_get_callback handle = %s , user_data = %s \n", (char *)handle, (char *)user_data); + + char *test_text = NULL; + + account_get_user_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_display_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_email_address(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_icon_path(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_source(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_package_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_domain_name(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + + _account_free_text(test_text); + + account_get_access_token(handle, &test_text); + ACCOUNT_SLOGD("_account_get_callback : %s\n", test_text); + _account_free_text(test_text); + + int i=0, test_int=0; + + account_auth_type_e auth_type; + account_get_auth_type(handle, &auth_type); + ACCOUNT_SLOGD("account_get_auth_type : %d\n", auth_type); + + account_secrecy_state_e secret; + account_get_secret(handle, &secret); + ACCOUNT_SLOGD("account_get_secret : %d\n", secret); + + account_sync_state_e sync_support; + account_get_sync_support(handle, &sync_support); + ACCOUNT_SLOGD("account_get_sync_support : %d\n", sync_support); + + for(i=0;i<USER_INT_CNT;i++) + { + account_get_user_int(handle, i, &test_int); + ACCOUNT_SLOGD("_account_get_callback : %d\n", test_int); + } + + account_get_capability_all(handle, _capability_get_callback, NULL); + + return TRUE; +} + + +static int utc1_get_account_by_id() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_query_account_by_account_id(account_id, &account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + _account_get_account_info(account); + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc2_get_account_by_id() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_create(&account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_query_account_by_account_id(account_id, &account); + + _account_get_account_info(account); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_destroy(account); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc1_get_account_by_user_name() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_query_account_by_user_name(_account_get_callback, "usernamed-wy1115", NULL); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc2_get_account_by_user_name() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + char *user_data = "test user_data"; + + ret = account_query_account_by_user_name(_account_get_callback, "usernamed-wy1115", (void *)user_data); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc1_get_account_by_capability() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_query_account_by_capability(_account_get_callback, ACCOUNT_SUPPORTS_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_ENABLED, NULL); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc2_get_account_by_capability() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_query_account_by_capability(_account_get_callback, ACCOUNT_SUPPORTS_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_DISABLED, NULL); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc3_get_account_by_capability() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_query_account_by_capability(_account_get_callback, ACCOUNT_SUPPORTS_CAPABILITY_PHOTO, -1, NULL); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc4_get_account_by_capability() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_query_account_by_capability(_account_get_callback, ACCOUNT_SUPPORTS_CAPABILITY_PHOTO, ACCOUNT_CAPABILITY_DISABLED, NULL); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc5_get_account_by_capability() +{ + int ret = - 1; + + account_h account = NULL; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_query_account_by_capability(_account_get_callback, ACCOUNT_SUPPORTS_CAPABILITY_PHOTO, -1, NULL); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, account=%p\n", __LINE__, ret, account); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, account=%p\n", __LINE__, ret, account); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc1_get_all_accounts() +{ + int ret = - 1; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_foreach_account_from_db(_account_get_callback, NULL); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, \n", __LINE__, ret); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +static int utc2_get_all_accounts() +{ + int ret = - 1; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + char *user_data = "test user_data"; + + ret = account_foreach_account_from_db(_account_get_callback, (void *)user_data); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d \n", __LINE__, ret); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d \n", __LINE__, ret); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + return 1; +} + +bool _utc_capability_get_callback(const char* capability_type, account_capability_state_e capability_value, void* user_data) +{ + char* test_type = (char*)capability_type; + int test_value = capability_value; + + ACCOUNT_SLOGD("_capability_get_callback test_type = : %s\n", test_type); + ACCOUNT_SLOGD("_capability_get_callback test_value = : %d\n", test_value); + return TRUE; + +} + +static int utc1_account_get_capability_by_account_id() +{ + int ret = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_query_capability_by_account_id(_utc_capability_get_callback, account_id, NULL); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d,\n", __LINE__, ret); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, \n", __LINE__, ret); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return 1; +} + +static int utc2_account_get_capability_by_account_id() +{ + int ret = -1; + + char *user_data = "test user_data"; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_query_capability_by_account_id(_utc_capability_get_callback, account_id, (void *)user_data); + + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, \n", __LINE__, ret); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return 1; +} + +static int utc_account_delete_by_id() +{ + int ret = -1; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_delete_from_db_by_id(account_id); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d, \n", __LINE__, ret); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return 1; +} + +static int utc_account_delete_by_user_name() +{ + int ret = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_delete_from_db_by_user_name("usernamed-wy1115", "usernamed-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d \n", __LINE__, ret); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d \n", __LINE__, ret); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return 1; +} + +static int utc_account_delete_by_package_name() +{ + int ret = -1; + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_delete_from_db_by_package_name("usernamed-com.samsung.account"); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d\n", __LINE__, ret); + } + else + { + ACCOUNT_SLOGD("(%d)-[Account-else loop] ret = %d\n", __LINE__, ret); + } + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return 1; +} + +static int utc_account_update_sync_status_by_id() +{ + int ret = -1; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_update_sync_status_by_id(account_id, ACCOUNT_SYNC_STATUS_IDLE); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return ret; +} + +static int utc_account_get_application_capability_support() +{ + int ret = -1; + bool test = false; + + ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_get_application_capability_support("com.samsung.facebook", ACCOUNT_SUPPORTS_CAPABILITY_CONTACT, &test); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + return ret; +} + +static int utc_account_get_and_update() +{ + int ret = -1; + account_h account = NULL; + + ret = account_connect(); + ACCOUNT_SLOGD("%s(%d) ret=%x\n", __FUNCTION__, __LINE__, ret); + + ret = account_create(&account); + ACCOUNT_SLOGD("%s(%d) ret=%x\n", __FUNCTION__, __LINE__, ret); + + ret = account_query_account_by_account_id( 2, &account); + ACCOUNT_SLOGD("%s(%d) ret=%x\n", __FUNCTION__, __LINE__, ret); + + ret = account_set_access_token(account, "ACCESSSSSSSSSSSSSSSSSSSFASFASDGDSFFASDFASFDSDGAASDFASDGDFDFGAFASDFASFASDFASASGSGASDFASFSADDSGASGASGGASDFASDFASGSAASDFAAAG"); + ACCOUNT_SLOGD("%s(%d) ret=%x\n", __FUNCTION__, __LINE__, ret); + + ret = account_update_to_db_by_id( account, 2); + ACCOUNT_SLOGD("%s(%d) ret=%x\n", __FUNCTION__, __LINE__, ret); + + ret = account_destroy(account); + ACCOUNT_SLOGD("%s(%d) ret=%x\n", __FUNCTION__, __LINE__, ret); + + ret = account_disconnect(); + ACCOUNT_SLOGD("%s(%d) ret=%x\n", __FUNCTION__, __LINE__, ret); + + return 1; +} + +int main(int argc, char** argv) +{ +#if 0 + utc_notify_account_insert_update_delete(); +#else + int account_id = -1; + int cap_key = -1; + int cap_value = -1; + int user_resp = 0; + char temp[128]; + memset(temp, 0x00, sizeof(temp)); + + ACCOUNT_SLOGD("\n\n**************************** Account Unit Test case Execution Suite ************************************ \n\n"); + ACCOUNT_SLOGD("1. Press 1 for account insert test \n"); + ACCOUNT_SLOGD("2. Press 2 for account update test \n"); + ACCOUNT_SLOGD("3. Press 3 for account delete test \n"); + ACCOUNT_SLOGD("4. Press 4 for query account test \n"); + if (scanf("%d", &user_resp) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + + if (user_resp == 1) { + ACCOUNT_SLOGD("In Account Insert Test Mode \n"); + account_id = _account_insert_test_new(); + if(account_id > 0) + { + ACCOUNT_SLOGD("(%d)-[Account] account insert test Success!! account id = %d\n", __LINE__, account_id); + } + utc_account_get_and_update(); + } else if (user_resp == 2) { + ACCOUNT_SLOGD("In Account Update Test Mode \n"); + ACCOUNT_SLOGD("1. Press 1 to upadte account by id test \n"); + ACCOUNT_SLOGD("2. Press 2 for update account by user name test \n"); + if (scanf("%d", &user_resp) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + if (user_resp == 1) { + ACCOUNT_SLOGD("Enter Account Id to be Updated \n"); + if (scanf("%d", &account_id) != 1){ + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + if (_account_update_test_new(account_id) == ACCOUNT_ERROR_NONE) + ACCOUNT_SLOGD("Account update Success \n"); + else + ACCOUNT_SLOGD("Account update Failed \n"); + } else if (user_resp == 2) { + ACCOUNT_SLOGD("Enter Account user name to be Updated \n"); + memset(temp, 0x00, sizeof(temp)); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + char temp2[128]; + memset(temp2, 0x00, sizeof(temp2)); + ACCOUNT_SLOGD("Enter Account package name to be Updated \n"); + if (scanf("%s", temp2) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + if (_account_update_test_new_by_user_name(temp, temp2) == ACCOUNT_ERROR_NONE) + ACCOUNT_SLOGD("Account update Success \n"); + else + ACCOUNT_SLOGD("Account update Failed \n"); + } else { + ACCOUNT_SLOGD("Wrong info entered \n"); + exit(0); + } + } else if (user_resp == 3) { + ACCOUNT_SLOGD("In Account Delete Test Mode \n"); + ACCOUNT_SLOGD("1. Press 1 to delete account by id test \n"); + ACCOUNT_SLOGD("2. Press 2 to delete account by user name test \n"); + ACCOUNT_SLOGD("3. Press 3 to delete account by package name test \n"); + if (scanf("%d", &user_resp) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + if (user_resp == 1) { + ACCOUNT_SLOGD("Enter Account Id to be Deleted \n"); + if (scanf("%d", &account_id) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + int ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + if (account_delete_from_db_by_id(account_id) == ACCOUNT_ERROR_NONE) + ACCOUNT_SLOGD("Account delete Success \n"); + else + ACCOUNT_SLOGD("Account delete Failed \n"); + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + } else if (user_resp == 2) { + ACCOUNT_SLOGD("Enter Account user name to be Deleted \n"); + memset(temp, 0x00, sizeof(temp)); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + char temp2[128]; + memset(temp2, 0x00, sizeof(temp2)); + ACCOUNT_SLOGD("Enter Account package name to be Deleted \n"); + if (scanf("%s", temp2) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + int ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + if (account_delete_from_db_by_user_name(temp, temp2) == ACCOUNT_ERROR_NONE) + ACCOUNT_SLOGD("Account delete Success \n"); + else + ACCOUNT_SLOGD("Account delete Failed \n"); + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + } else if (user_resp == 3) { + ACCOUNT_SLOGD("Enter Account package name to be Deleted \n"); + memset(temp, 0x00, sizeof(temp)); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + int ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + if (account_delete_from_db_by_package_name(temp) == ACCOUNT_ERROR_NONE ) + ACCOUNT_SLOGD("Account delete Success \n"); + else + ACCOUNT_SLOGD("Account delete Failed \n"); + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + + } else { + ACCOUNT_SLOGD("Wrong info entered \n"); + exit(0); + } + + } else if (user_resp == 4) { + ACCOUNT_SLOGD("In Account Query Test Mode \n"); + ACCOUNT_SLOGD("1. Press 1 to Query account by id test \n"); + ACCOUNT_SLOGD("2. Press 2 to Query account by user name test \n"); + ACCOUNT_SLOGD("3. Press 3 to Query account by package name test \n"); + ACCOUNT_SLOGD("4. Press 4 to Query account by capability test \n"); + if (scanf("%d", &user_resp) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + if (user_resp == 1) { + ACCOUNT_SLOGD("Enter Account Id to be Queried \n"); + if (scanf("%d", &account_id) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + account_h account = NULL; + account_connect(); + account_create(&account); + if (account_query_account_by_account_id(account_id, &account) == ACCOUNT_ERROR_NONE) + ACCOUNT_SLOGD("Account Queried Successfully \n"); + else + ACCOUNT_SLOGD("Account Queried failed \n"); + account_destroy(account); + account_disconnect(); + } else if (user_resp == 2) { + ACCOUNT_SLOGD("Enter Account user name to be Queried \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + int ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + if (account_query_account_by_user_name(_account_get_callback, temp, NULL) == ACCOUNT_ERROR_NONE) + ACCOUNT_SLOGD("Account Queried Successfully \n"); + else + ACCOUNT_SLOGD("Account Queried failed \n"); + + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + } else if (user_resp == 3) { + ACCOUNT_SLOGD("Enter Account package name to be Queried \n"); + if (scanf("%s", temp) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + int ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d\n", __LINE__, ret); + } + if (account_query_account_by_package_name(_account_get_callback, temp, NULL) == ACCOUNT_ERROR_NONE) + ACCOUNT_SLOGD("Account Queried Successfully \n"); + else + ACCOUNT_SLOGD("Account Queried failed \n"); + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + } else if (user_resp == 4) { + ACCOUNT_SLOGD("Enter Account capability key to be Queried \n"); + if (scanf("%d", &cap_key) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + ACCOUNT_SLOGD("Enter Account capability key's value to be Queried \n"); + if (scanf("%d", &cap_value) != 1) { + ACCOUNT_SLOGD("Scanf Failed!!!\n"); + exit(0); + } + int ret = account_connect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d\n", __LINE__, ret); + } + if (account_query_account_by_capability(_account_get_callback, ACCOUNT_SUPPORTS_CAPABILITY_PHOTO, cap_value, NULL) == ACCOUNT_ERROR_NONE) + ACCOUNT_SLOGD("Account Queried Successfully \n"); + else + ACCOUNT_SLOGD("Account Queried failed \n"); + ret = account_disconnect(); + if(ret != ACCOUNT_ERROR_NONE) + { + ACCOUNT_SLOGD("(%d)-[Account] ret = %d, \n", __LINE__, ret); + } + } else { + ACCOUNT_SLOGD("Wrong info entered \n"); + exit(0); + } + + } else { + ACCOUNT_SLOGD("Wrong info entered \n"); + exit(0); + } + + //utc calls +#if 1 + //utc insert + utc1_account_insert(); + utc2_account_insert(); + utc3_account_insert(); + utc4_account_insert(); + utc5_account_insert(); + utc6_account_insert(); + utc7_account_insert(); + utc8_account_insert(); + utc9_account_insert(); + utc10_account_insert(); + utc11_account_insert(); + utc12_account_insert(); + utc13_account_insert(); + utc14_account_insert(); + utc15_account_insert(); + utc16_account_insert(); + utc17_account_insert(); + utc18_account_insert(); + utc19_account_insert(); + utc20_account_insert(); + utc21_account_insert(); + utc22_account_insert(); + utc23_account_insert(); +#endif + + //utc update +#if 1 + utc1_account_update(); + utc2_account_update(); + utc3_account_update(); + utc4_account_update(); + utc5_account_update(); + utc6_account_update(); + utc7_account_update(); + utc8_account_update(); + utc9_account_update(); + utc10_account_update(); + utc11_account_update(); + utc12_account_update(); + utc13_account_update(); + utc14_account_update(); + utc15_account_update(); + utc16_account_update(); + utc17_account_update(); + utc18_account_update(); + utc19_account_update(); + utc20_account_update(); + utc21_account_update(); + utc22_account_update(); + utc23_account_update(); + utc24_account_update(); + utc25_account_update(); + utc26_account_update(); + utc27_account_update(); +#endif + + //utc get account by id +#if 1 + utc1_get_account_by_id(); + utc2_get_account_by_id(); +#endif + + //utc get account by user name +#if 1 + utc1_get_account_by_user_name(); + utc2_get_account_by_user_name(); +#endif + + //utc get account by capability +#if 1 + utc1_get_account_by_capability(); + utc2_get_account_by_capability(); + utc3_get_account_by_capability(); + utc4_get_account_by_capability(); + utc5_get_account_by_capability(); +#endif + + //utc get all accounts +#if 1 + utc1_get_all_accounts(); + utc2_get_all_accounts(); +#endif + + //utc get capability by account id +#if 1 + utc1_account_get_capability_by_account_id(); + utc2_account_get_capability_by_account_id(); +#endif + + //utc update sync status by id +#if 1 + utc_account_update_sync_status_by_id(); +#endif + + //utc get application capability support +#if 1 + utc_account_get_application_capability_support(); +#endif + +#if 1 + utc_account_delete_by_id(); + utc_account_delete_by_user_name(); + utc_account_delete_by_package_name(); +#endif + +#endif + + return 0; +} + |