From 5daeaaa22f47680ac5804d8d8a8a55b116e5b008 Mon Sep 17 00:00:00 2001 From: Hyihong Chae Date: Mon, 26 Oct 2015 14:48:39 +0900 Subject: [PATCH] Code Sync up from tizen_2.4 Change-Id: Icbef7a255d37531e0549daac644ea8ca8cbca668 Signed-off-by: HyiHong Chae --- AUTHORS | 1 + CMakeLists.txt | 90 +++ LICENSE.APLv2 | 206 +++++++ NOTICE | 3 + capi-network-mtp.manifest | 6 + capi-network-mtp.pc.in | 15 + include/mtp.h | 747 +++++++++++++++++++++++ include/mtp_db.h | 37 ++ include/mtp_debug.h | 93 +++ include/mtp_gdbus.h | 32 + include/mtp_gdbus_deviceinfo.h | 30 + include/mtp_gdbus_manager.h | 39 ++ include/mtp_gdbus_objectinfo.h | 30 + include/mtp_gdbus_storageinfo.h | 36 ++ include/mtp_internal.h | 58 ++ packaging/capi-network-mtp.spec | 68 +++ src/mtp.c | 1027 ++++++++++++++++++++++++++++++++ src/mtp_db.c | 143 +++++ src/mtp_gdbus_deviceinfo.c | 124 ++++ src/mtp_gdbus_manager.c | 348 +++++++++++ src/mtp_gdbus_objectinfo.c | 86 +++ src/mtp_gdbus_storageinfo.c | 155 +++++ src/mtp_gdbuslib.xml | 138 +++++ test/CMakeLists.txt | 18 + test/mtp_unit_test.c | 1254 +++++++++++++++++++++++++++++++++++++++ 25 files changed, 4784 insertions(+) create mode 100755 AUTHORS create mode 100755 CMakeLists.txt create mode 100755 LICENSE.APLv2 create mode 100755 NOTICE create mode 100755 capi-network-mtp.manifest create mode 100755 capi-network-mtp.pc.in create mode 100755 include/mtp.h create mode 100755 include/mtp_db.h create mode 100755 include/mtp_debug.h create mode 100755 include/mtp_gdbus.h create mode 100755 include/mtp_gdbus_deviceinfo.h create mode 100755 include/mtp_gdbus_manager.h create mode 100755 include/mtp_gdbus_objectinfo.h create mode 100755 include/mtp_gdbus_storageinfo.h create mode 100755 include/mtp_internal.h create mode 100755 packaging/capi-network-mtp.spec create mode 100755 src/mtp.c create mode 100755 src/mtp_db.c create mode 100755 src/mtp_gdbus_deviceinfo.c create mode 100755 src/mtp_gdbus_manager.c create mode 100755 src/mtp_gdbus_objectinfo.c create mode 100755 src/mtp_gdbus_storageinfo.c create mode 100755 src/mtp_gdbuslib.xml create mode 100755 test/CMakeLists.txt create mode 100755 test/mtp_unit_test.c diff --git a/AUTHORS b/AUTHORS new file mode 100755 index 0000000..d8dcd77 --- /dev/null +++ b/AUTHORS @@ -0,0 +1 @@ +Jihoon Jung diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100755 index 0000000..eba39c8 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,90 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) + +# project +SET(project_prefix "capi") +SET(prefix "/usr") +SET(libdir ${LIB_INSTALL_DIR}) +SET(version "0.0.1") +SET(maintainer "Jihoon Jung ") +SET(description "A MTP library in Tizen Native API") +SET(service "network") +SET(submodule "mtp") + +# for package file +SET(dependents "dlog glib-2.0 gio-2.0 capi-base-common gio-unix-2.0 sqlite3") +SET(pc_dependents "capi-base-common") + +SET(fw_name "${project_prefix}-${service}-${submodule}") + +FIND_PROGRAM(GDBUS_CODEGEN NAMES gdbus-codegen) +EXEC_PROGRAM(${GDBUS_CODEGEN} ARGS + " \\ + --generate-c-code ${CMAKE_CURRENT_SOURCE_DIR}/src/mtp_gdbuslib \\ + --c-namespace mtp_gdbuslib \\ + --interface-prefix org.tizen.mtp. \\ + ${CMAKE_CURRENT_SOURCE_DIR}/src/mtp_gdbuslib.xml \\ + ") + +PROJECT(${fw_name}) + +SET(CMAKE_INSTALL_PREFIX ${prefix}) +SET(PREFIX ${CMAKE_INSTALL_PREFIX}) +SET(VERSION ${version}) + +SET(INC_DIR include) +INCLUDE_DIRECTORIES(${INC_DIR}) +INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/src) + +INCLUDE(FindPkgConfig) +pkg_check_modules(${fw_name} REQUIRED ${dependents}) +FOREACH(flag ${${fw_name}_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror") +SET(CMAKE_C_FLAGS_DEBUG "-O0 -g") + +ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"") +ADD_DEFINITIONS("-DTIZEN_DEBUG") + +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=%{_libdir}") + +SET(SOURCES src/mtp.c + src/mtp_gdbuslib.c + src/mtp_gdbus_deviceinfo.c + src/mtp_gdbus_manager.c + src/mtp_gdbus_storageinfo.c + src/mtp_gdbus_objectinfo.c + src/mtp_db.c) + +ADD_LIBRARY(${fw_name} SHARED ${SOURCES}) + +TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS}) + +SET_TARGET_PROPERTIES(${fw_name} + PROPERTIES + VERSION ${FULLVER} + SOVERSION ${MAJORVER} + CLEAN_DIRECT_OUTPUT 1 +) + +INSTALL(TARGETS ${fw_name} DESTINATION ${libdir}) +INSTALL( + DIRECTORY ${INC_DIR}/ DESTINATION include + FILES_MATCHING + PATTERN "${INC_DIR}/*.h" + ) + +SET(PC_NAME ${fw_name}) +SET(PC_REQUIRED ${pc_dependents}) +SET(PC_LDFLAGS -l${fw_name}) + +CONFIGURE_FILE( + ${fw_name}.pc.in + ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc + @ONLY +) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${libdir}/pkgconfig) + +ADD_SUBDIRECTORY(test) + diff --git a/LICENSE.APLv2 b/LICENSE.APLv2 new file mode 100755 index 0000000..2e43946 --- /dev/null +++ b/LICENSE.APLv2 @@ -0,0 +1,206 @@ +Copyright (c) 2000 - 2012 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/NOTICE b/NOTICE new file mode 100755 index 0000000..0e0f016 --- /dev/null +++ b/NOTICE @@ -0,0 +1,3 @@ +Copyright (c) Samsung Electronics Co., Ltd. All rights reserved. +Except as noted, this software is licensed under Apache License, Version 2. +Please, see the LICENSE.APLv2 file for Apache License terms and conditions. diff --git a/capi-network-mtp.manifest b/capi-network-mtp.manifest new file mode 100755 index 0000000..ca37499 --- /dev/null +++ b/capi-network-mtp.manifest @@ -0,0 +1,6 @@ + + + + + + diff --git a/capi-network-mtp.pc.in b/capi-network-mtp.pc.in new file mode 100755 index 0000000..c45e5b2 --- /dev/null +++ b/capi-network-mtp.pc.in @@ -0,0 +1,15 @@ + +# Package Information for pkg-config + +prefix=@PREFIX@ +exec_prefix=/usr +libdir=@libdir@ +includedir=/usr/include/ + +Name: @PC_NAME@ +Description: @PACKAGE_DESCRIPTION@ +Version: @VERSION@ +Requires: @PC_REQUIRED@ +Libs: -L${libdir} @PC_LDFLAGS@ +Cflags: -I${includedir} + diff --git a/include/mtp.h b/include/mtp.h new file mode 100755 index 0000000..1297417 --- /dev/null +++ b/include/mtp.h @@ -0,0 +1,747 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 __MTP_H__ +#define __MTP_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef MTP_API +#define MTP_API +#endif + +/** + * @file mtp.h + * @brief This file contains the MTP API + */ +#define MTP_ERROR_CLASS TIZEN_ERROR_NETWORK_CLASS /* Need define mtp error class */ + +/** + * @brief Structure for mtp device + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + */ +typedef struct _mtp_device { + int bus_location; + char *model_name; +} mtp_device; + +/** + * @brief Structure for mtp device list + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + */ +typedef struct _mtp_device_list { + mtp_device *devices; + int device_num; +} mtp_device_list; + +/** + * @brief Error codes reported by the MTP API. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + */ +typedef enum { + MTP_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ + MTP_ERROR_GENERAL = MTP_ERROR_CLASS | 0x01, /**< A general error occurred */ + MTP_ERROR_IO_ERROR = TIZEN_ERROR_IO_ERROR, /**< I/O error */ + MTP_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ + MTP_ERROR_NO_DEVICE = MTP_ERROR_CLASS | 0x02, /**< MTP have not any device */ + MTP_ERROR_ALLOC_FAIL = MTP_ERROR_CLASS | 0x03, /**< Memory Allocation failed */ + MTP_ERROR_PLUGIN = MTP_ERROR_CLASS | 0x04, /**< Plugin failed */ + MTP_ERROR_DB = MTP_ERROR_CLASS | 0x05, /**< Plugin failed */ + MTP_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ + MTP_ERROR_NOT_INITIALIZED = MTP_ERROR_CLASS | 0x06, /**< MTP is not supported */ + MTP_ERROR_NOT_ACTIVATED = MTP_ERROR_CLASS | 0x07, /**< MTP is not activated */ + MTP_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< MTP is not supported */ +} mtp_error_e; + +/** + * @brief Enumerations for MTP file type + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + */ +typedef enum { + MTP_FILETYPE_FOLDER, /**< FOLDER file type */ + MTP_FILETYPE_WAV, /**< WAV file type */ + MTP_FILETYPE_MP3, /**< MP3 file type */ + MTP_FILETYPE_WMA, /**< WMA file type */ + MTP_FILETYPE_OGG, /**< OGG file type */ + MTP_FILETYPE_AUDIBLE, /**< AUDIBLE file type */ + MTP_FILETYPE_MP4, /**< MP4 file type */ + MTP_FILETYPE_UNDEF_AUDIO, /**< UNDEF_AUDIO file type */ + MTP_FILETYPE_WMV, /**< WMV file type */ + MTP_FILETYPE_AVI, /**< AVI file type */ + MTP_FILETYPE_MPEG, /**< MPEG file type */ + MTP_FILETYPE_ASF, /**< ASF file type */ + MTP_FILETYPE_QT, /**< QT file type */ + MTP_FILETYPE_UNDEF_VIDEO, /**< UNDEF_VIDEO file type */ + MTP_FILETYPE_JPEG, /**< JPEG file type */ + MTP_FILETYPE_JFIF, /**< JFIF file type */ + MTP_FILETYPE_TIFF, /**< TIFF file type */ + MTP_FILETYPE_BMP, /**< BMP file type */ + MTP_FILETYPE_GIF, /**< GIF file type */ + MTP_FILETYPE_PICT, /**< PICT file type */ + MTP_FILETYPE_PNG, /**< PNG file type */ + MTP_FILETYPE_VCALENDAR1, /**< VCALENDAR1 file type */ + MTP_FILETYPE_VCALENDAR2, /**< VCALENDAR2 file type */ + MTP_FILETYPE_VCARD2, /**< VCARD2 file type */ + MTP_FILETYPE_VCARD3, /**< VCARD3 file type */ + MTP_FILETYPE_WINDOWSIMAGEFORMAT, /**< WINDOWSIMAGEFORMAT file type */ + MTP_FILETYPE_WINEXEC, /**< WINEXEC file type */ + MTP_FILETYPE_TEXT, /**< TEXT file type */ + MTP_FILETYPE_HTML, /**< HTML file type */ + MTP_FILETYPE_FIRMWARE, /**< FIRMWARE file type */ + MTP_FILETYPE_AAC, /**< AAC file type */ + MTP_FILETYPE_MEDIACARD, /**< MEDIACARD file type */ + MTP_FILETYPE_FLAC, /**< FLAC file type */ + MTP_FILETYPE_MP2, /**< MP2 file type */ + MTP_FILETYPE_M4A, /**< M4A file type */ + MTP_FILETYPE_DOC, /**< DOC file type */ + MTP_FILETYPE_XML, /**< XML file type */ + MTP_FILETYPE_XLS, /**< XLS file type */ + MTP_FILETYPE_PPT, /**< PPT file type */ + MTP_FILETYPE_MHT, /**< MHT file type */ + MTP_FILETYPE_JP2, /**< JP2 file type */ + MTP_FILETYPE_JPX, /**< JPX file type */ + MTP_FILETYPE_ALBUM, /**< ALBUM file type */ + MTP_FILETYPE_PLAYLIST, /**< PLAYLIST file type */ + MTP_FILETYPE_UNKNOWN, /**< Unknown file type */ + + MTP_FILETYPE_ALL, /**< helper enum value for certain function */ + MTP_FILETYPE_ALL_IMAGE /**< helper enum value for certain function */ +} mtp_filetype_e; + +/** + * @brief Enumerations for MTP event type + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + */ +typedef enum { + MTP_EVENT_UNKNOWN, /**< Unknown event type */ + MTP_EVENT_STORAGE_ADDED, /**< Storage is added */ + MTP_EVENT_STORAGE_REMOVED, /**< Storage is removed */ + MTP_EVENT_OBJECT_ADDED, /**< Object is added */ + MTP_EVENT_OBJECT_REMOVED, /**< Object is removed */ + MTP_EVENT_DEVICE_ADDED, /**< Device is added */ + MTP_EVENT_DEVICE_REMOVED /**< Device is removed */ +} mtp_event_e; + +/** + * @brief Called after mtp_set_mtp_event_cb() has completed. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * + * @param [in] event The event + * @param [in] arg The argument + * @param [in] user_data The user data passed from the callback registration function + * + * @see mtp_set_mtp_event_cb() + * @see mtp_unset_mtp_event_cb() + */ +typedef void (* mtp_event_cb)(mtp_event_e event, int arg, void *user_data); + +/** + * @brief Initializes for using MTP. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * @remarks This function must be called before proceeding any other mtp functions\n + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @see mtp_deinitialize() + */ +MTP_API int mtp_initialize(void); + +/** + * @brief Get device list. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [out] dev_list All current device list + */ +MTP_API int mtp_get_device_list(mtp_device_list **dev_list); + +/** + * @brief Get device handler from bus location + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] bus_location The bus location + * @param [out] device_handle The device handle + * + * @see mtp_initialize() + */ +MTP_API int mtp_get_device_handle(int bus_location, int* device_handle); + +/** + * @brief Get storage ids from device + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [out] storage_id Current storage id list + * @param [out] storage_num Length of storage id list + * + * @see mtp_get_device_handle() + */ +MTP_API int mtp_get_storage_ids(int device_handle, int **storage_id, int* storage_num); + +/** + * @brief Get object handles from device + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] storage_id The storage id + * @param [in] format The file type what you want + * @param [in] parent_object_handle The parent object handle + * @param [out] object_handles The object handle list + * @param [out] object_num Length of object handle list + * + * @see mtp_get_device_handle() + * @see mtp_get_storage_ids() + */ +MTP_API int mtp_get_object_handles(int device_handle, int storage_id, int format, + int parent_object_handle, int **object_handles, int* object_num); + +/** + * @brief Delete object from device + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * + * @see mtp_get_device_handle() + * @see mtp_get_object_handles() + */ +MTP_API int mtp_delete_object(int device_handle, int object_handle); + +/** + * @brief Get object from object handle + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [in] dest_path The dest path + * + * @see mtp_get_device_handle() + * @see mtp_get_object_handles() + */ +MTP_API int mtp_get_object(int device_handle, int object_handle, char *dest_path); + +/** + * @brief Get thumbnail from object handle + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [in] dest_path The dest path + * + * @see mtp_get_device_handle() + * @see mtp_get_object_handles() + */ +MTP_API int mtp_get_thumbnail(int device_handle, int object_handle, char *dest_path); + +/** + * @brief Registers a callback function for receiving MTP event. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * + * @detail If device state is changed, DEVICE_ADD or DEVICE_REMOVE event is occur. \n + * If storage state is changed, STORAGE_ADD or STORAGE_REMOVE event is occur. \n + * If object state is changed, OBJECT_ADD or OBJECT_REMOVE event is occur. + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] callback The callback + * @param [in] user_data The user data + * + * @see mtp_unset_mtp_event_cb() + */ +MTP_API int mtp_set_mtp_event_cb(mtp_event_cb callback, void *user_data); + +/** + * @brief Unregisters the callback function. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @see mtp_set_mtp_event_cb() + */ +MTP_API int mtp_unset_mtp_event_cb(void); + +/** + * @brief Deinitializes MTP operation. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_MANAGER_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @see mtp_initialize() + */ +MTP_API int mtp_deinitialize(void); + +/** + * @brief Get the manufacturer name of the device information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_DEVICEINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [out] manufacturername The manufacturername of Device information + * + * @see mtp_get_device_handle() + */ +MTP_API int mtp_deviceinfo_get_manufacturername(int device_handle, char **manufacturername); + +/** + * @brief Get the model name of the device information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_DEVICEINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [out] modelname The modelname of Device information + * + * @see mtp_get_device_handle() + */ +MTP_API int mtp_deviceinfo_get_modelname(int device_handle, char **modelname); + +/** + * @brief Get the serial number of the device information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_DEVICEINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [out] serialnumber The serialnumber of Device information + * + * @see mtp_get_device_handle() + */ +MTP_API int mtp_deviceinfo_get_serialnumber(int device_handle, char **serialnumber); + +/** + * @brief Get the device version of the device information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_DEVICEINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [out] serialnumber The deviceversion of Device information + * + * @see mtp_get_device_handle() + */ +MTP_API int mtp_deviceinfo_get_deviceversion(int device_handle, char **deviceversion); + +/** + * @brief Get the description of the storage information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_STORAGEINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] storage_id The storage id + * @param [out] description The description of Storage information + * + * @see mtp_get_storage_ids() + */ +MTP_API int mtp_storageinfo_get_description(int device_handle, int storage_id, char **description); + +/** + * @brief Get the freespace of the storage information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_STORAGEINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] storage_id The storage id + * @param [out] freespace The freespace of Storage information + * + * @see mtp_get_storage_ids() + */ +MTP_API int mtp_storageinfo_get_freespace(int device_handle, int storage_id, guint64 *freespace); + +/** + * @brief Get the max capacity of the storage information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_STORAGEINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] storage_id The storage id + * @param [out] maxcapacity The maxcapacity of Storage information + * + * @see mtp_get_storage_ids() + */ +MTP_API int mtp_storageinfo_get_maxcapacity(int device_handle, int storage_id, guint64 *maxcapacity); + +/** + * @brief Get the storage type of the storage information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_STORAGEINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] storage_id The storage id + * @param [out] storagetype The storagetype of Storage information + * + * @see mtp_get_storage_ids() + */ +MTP_API int mtp_storageinfo_get_storagetype(int device_handle, int storage_id, int *storagetype); + +/** + * @brief Get the volumeidentifier of the storage information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_STORAGEINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] storage_id The storage id + * @param [out] volumeidentifier The volumeidentifier of Storage information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_storageinfo_get_volumeidentifier(int device_handle, int storage_id, char **volumeidentifier); + +/** + * @brief Get the filename of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] filename The filename of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_filename(int device_handle, int object_handle, char **filename); + +/** + * @brief Get the keywords of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] keywords The keywords of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_keywords(int device_handle, int object_handle, char **keywords); + +/** + * @brief Get the association desc of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] asso_desc The association description of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_association_desc(int device_handle, int object_handle, int *asso_desc); + +/** + * @brief Get the association type of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] asso_type The association type of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_association_type(int device_handle, int object_handle, int *asso_type); + +/** + * @brief Get the size of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] size The size of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_size(int device_handle, int object_handle, int *size); + +/** + * @brief Get the parent object handle of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] parent_object_handle The parent of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_parent_object_handle(int device_handle, int object_handle, int *parent_object_handle); + +/** + * @brief Get the storage id of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] storage_id The storage id of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_storage_id(int device_handle, int object_handle, int *storage_id); + +/** + * @brief Get the data created time of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] data_created The data created time of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_data_created(int device_handle, int object_handle, int *data_created); + +/** + * @brief Get the data modified time of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] data_modified The data modified time of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_data_modified(int device_handle, int object_handle, int *data_modified); + +/** + * @brief Get the format of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] format The image format of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_format(int device_handle, int object_handle, int *format); + +/** + * @brief Get the image pix depth of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] depth The image pixel depth of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_image_pix_depth(int device_handle, int object_handle, int *depth); + +/** + * @brief Get the image pix width of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] width The image pixel width of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_image_pix_width(int device_handle, int object_handle, int *width); + +/** + * @brief Get the image pix height of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] height The image pixel height of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_image_pix_height(int device_handle, int object_handle, int *height); + +/** + * @brief Get the thumbnail size of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] size The thumbnail size of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_thumbnail_size(int device_handle, int object_handle, int *size); + +/** + * @brief Get the thumbnail format of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] format The thumbnail format of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_thumbnail_format(int device_handle, int object_handle, int *format); + +/** + * @brief Get the thumbnail pix height of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] height The thumbnail pixel height of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_thumbnail_pix_height(int device_handle, int object_handle, int *height); + +/** + * @brief Get the thumbnail pix width of the object information. + * @since_tizen 3.0 + * @ingroup CAPI_NETWORK_MTP_OBJECTINFO_MODULE + * + * @return 0 on success, otherwise a negative error value. + * @retval #MTP_ERROR_NONE Successful + * + * @param [in] device_handle The device handle + * @param [in] object_handle The object handle + * @param [out] width The thumbnail pixel width of Object information + * + * @see mtp_get_object_handles() + */ +MTP_API int mtp_objectinfo_get_thumbnail_pix_width(int device_handle, int object_handle, int *width); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/mtp_db.h b/include/mtp_db.h new file mode 100755 index 0000000..a546820 --- /dev/null +++ b/include/mtp_db.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 __MTP_DB_H__ +#define __MTP_DB_H__ + +#include +#include +#include +#include +#include + +#include "mtp.h" +#include "mtp_internal.h" + +#define MTP_DB_FILE "/tmp/.mtp.db" +#define MTP_DB_TABLE "mtp_object_info" + +mtp_error_e mtp_db_init(void); +mtp_error_e mtp_db_get_object_info(int device_handle, int object_handle, mtp_object_info** object_info); +mtp_error_e mtp_db_deinit(void); + +#endif + diff --git a/include/mtp_debug.h b/include/mtp_debug.h new file mode 100755 index 0000000..a95ce04 --- /dev/null +++ b/include/mtp_debug.h @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 __MTP_DEBUG_H__ +#define __MTP_DEBUG_H__ + +#include + +#define COLOR_BLACK "\033[0;30m" +#define COLOR_RED "\033[0;31m" +#define COLOR_GREEN "\033[0;32m" +#define COLOR_BROWN "\033[0;33m" +#define COLOR_BLUE "\033[0;34m" +#define COLOR_PURPLE "\033[0;35m" +#define COLOR_CYAN "\033[0;36m" +#define COLOR_GRAY "\033[0;37m" +#define COLOR_END "\033[0;m" + +#define _ERR(fmt, ...) \ + do \ + { \ + LOGE(COLOR_RED fmt COLOR_END, ##__VA_ARGS__); \ + } \ + while (0) + +#define _INFO(fmt, ...) \ + do \ + { \ + LOGI(COLOR_GREEN fmt COLOR_END, ##__VA_ARGS__); \ + } \ + while (0) + +#define _WARN(fmt, ...) \ + do \ + { \ + LOGI(COLOR_BROWN fmt COLOR_END, ##__VA_ARGS__); \ + } \ + while (0) + +#define _DBG(fmt, ...) \ + do \ + { \ + LOGD(fmt, ##__VA_ARGS__); \ + } \ + while (0) + +#define _BEGIN() \ + do \ + { \ + LOGD(COLOR_BLUE "BEGIN >>>>" COLOR_END); \ + } \ + while (0) + +#define _END() \ + do \ + { \ + LOGD(COLOR_BLUE "END <<<<" COLOR_END); \ + } \ + while (0) + +#define cond_expr_ret(expr, val) \ + do {\ + if (expr) { \ + _ERR("[precond fail] expr : %s, ret : %d\n", #expr, val); \ + return (val); \ + } \ + } while(0) + +#define cond_ret(val) \ + do {\ + if(val) { \ + _ERR("[precond fail] ret : %d\n", val); \ + return (val); \ + } \ + } while(0) + +#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args) +#define TC_PRT(format, args...) PRT(format"\n", ##args) + +#endif diff --git a/include/mtp_gdbus.h b/include/mtp_gdbus.h new file mode 100755 index 0000000..a740ff1 --- /dev/null +++ b/include/mtp_gdbus.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 __MTP_GDBUS_H__ +#define __MTP_GDBUS_H__ + +#include +#include + +#include "mtp.h" +#include "mtp_gdbuslib.h" + +#define MTP_DBUS_SERVICE "org.tizen.mtp" +#define MTP_DBUS_MANAGER_PATH "/org/tizen/mtp/manager" +#define MTP_DBUS_DEVICEINFO_PATH "/org/tizen/mtp/deviceinfo" +#define MTP_DBUS_STORAGEINFO_PATH "/org/tizen/mtp/storageinfo" +#define MTP_DBUS_OBJECTINFO_PATH "/org/tizen/mtp/objectinfo" + +#endif diff --git a/include/mtp_gdbus_deviceinfo.h b/include/mtp_gdbus_deviceinfo.h new file mode 100755 index 0000000..69f2c92 --- /dev/null +++ b/include/mtp_gdbus_deviceinfo.h @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 __MTP_GDBUS_DEVICEINFO_H__ +#define __MTP_GDBUS_DEVICEINFO_H__ + +#include "mtp_gdbus.h" + +void mtp_gdbus_deviceinfo_proxy_init(void); +void mtp_gdbus_deviceinfo_proxy_deinit(void); + +mtp_error_e mtp_gdbus_deviceinfo_get_manufacturername(int mtp_handle, char **manufacturername); +mtp_error_e mtp_gdbus_deviceinfo_get_modelname(int mtp_handle, char **modelname); +mtp_error_e mtp_gdbus_deviceinfo_get_serialnumber(int mtp_handle, char **serialnumber); +mtp_error_e mtp_gdbus_deviceinfo_get_deviceversion(int mtp_handle, char **deviceversion); + +#endif diff --git a/include/mtp_gdbus_manager.h b/include/mtp_gdbus_manager.h new file mode 100755 index 0000000..9c9699c --- /dev/null +++ b/include/mtp_gdbus_manager.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 __MTP_GDBUS_MANAGER_H__ +#define __MTP_GDBUS_MANAGER_H__ + +#include "mtp_gdbus.h" + +mtp_error_e mtp_gdbus_manager_initialize(void); +mtp_error_e mtp_gdbus_manager_get_device_list(mtp_device_list **dev_list); +mtp_error_e mtp_gdbus_manager_get_device_handle(int bus_location, + int *device_handle); +mtp_error_e mtp_gdbus_manager_get_storage_ids(int device_handle, + int **storage_ids, int *storage_num); +mtp_error_e mtp_gdbus_manager_get_object_handles(int device_handle, + int storage_id, int format, int parent_object_handle, int **object_handles, int *object_num); +mtp_error_e mtp_gdbus_manager_delete_object(int device_handle, int object_handle); +mtp_error_e mtp_gdbus_manager_get_object(int device_handle, + int object_handle, char *dest_path); +mtp_error_e mtp_gdbus_manager_get_thumbnail(int device_handle, + int object_handle, char *dest_path); +mtp_error_e mtp_gdbus_manager_set_event_cb(mtp_event_cb callback, void *user_data); +mtp_error_e mtp_gdbus_manager_unset_event_cb(); +mtp_error_e mtp_gdbus_manager_deinitialize(void); + +#endif diff --git a/include/mtp_gdbus_objectinfo.h b/include/mtp_gdbus_objectinfo.h new file mode 100755 index 0000000..3c5930f --- /dev/null +++ b/include/mtp_gdbus_objectinfo.h @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 __MTP_GDBUS_OBJECTINFO_H__ +#define __MTP_GDBUS_OBJECTINFO_H__ + +#include "mtp_gdbus.h" + +void mtp_gdbus_objectinfo_proxy_init(void); +void mtp_gdbus_objectinfo_proxy_deinit(void); + +int mtp_gdbus_objectinfo_get_property(int device_handle, + int object_handle, int property, int *property_value); +int mtp_gdbus_objectinfo_get_property_string(int device_handle, + int object_handle, int property, char **property_value); + +#endif diff --git a/include/mtp_gdbus_storageinfo.h b/include/mtp_gdbus_storageinfo.h new file mode 100755 index 0000000..c4e90a3 --- /dev/null +++ b/include/mtp_gdbus_storageinfo.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 __MTP_GDBUS_STORAGEINFO_H__ +#define __MTP_GDBUS_STORAGEINFO_H__ + +#include "mtp_gdbus.h" + +void mtp_gdbus_storageinfo_proxy_init(void); +void mtp_gdbus_storageinfo_proxy_deinit(void); + +mtp_error_e mtp_gdbus_storageinfo_get_description(int device_handle, + int storage_id, char **description); +mtp_error_e mtp_gdbus_storageinfo_get_freespace(int device_handle, + int storage_id, guint64 *freespace); +mtp_error_e mtp_gdbus_storageinfo_get_maxcapacity(int device_handle, + int storage_id, guint64 *maxcapacity); +mtp_error_e mtp_gdbus_storageinfo_get_storagetype(int device_handle, + int storage_id, int *storagetype); +mtp_error_e mtp_gdbus_storageinfo_get_volumeidentifier(int device_handle, + int storage_id, char **volumeidentifier); + +#endif diff --git a/include/mtp_internal.h b/include/mtp_internal.h new file mode 100755 index 0000000..0702f5a --- /dev/null +++ b/include/mtp_internal.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 __MTP_INTERNAL_H__ +#define __MTP_INTERNAL_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define MTP_ERROR_DB -980 + +/* internal struct */ +typedef struct _mtp_object_info { + int StorageID; + int ObjectFormat; + int ProtectionStatus; + int ObjectCompressedSize; + int ThumbFormat; + int ThumbCompressedSize; + int ThumbPixWidth; + int ThumbPixHeight; + int ImagePixWidth; + int ImagePixHeight; + int ImageBitDepth; + int ParentObject; + int AssociationType; + int AssociationDesc; + int SequenceNumber; + char *Filename; + int CaptureDate; + int ModificationDate; + char *Keywords; +}mtp_object_info; + +/* internal api */ +MTP_API int mtp_objectinfo_get_object_info(int device_handle, int object_handle, mtp_object_info **object_info); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/packaging/capi-network-mtp.spec b/packaging/capi-network-mtp.spec new file mode 100755 index 0000000..139898b --- /dev/null +++ b/packaging/capi-network-mtp.spec @@ -0,0 +1,68 @@ +Name: capi-network-mtp +Summary: A MTP library in Native API +Version: 1.2.1 +Release: 1 +Group: Network & Connectivity/Other +License: Apache-2.0 +Source0: %{name}-%{version}.tar.gz + +# This package would be built only TV +%if "%{?tizen_profile_name}" != "tv" +ExcludeArch: %{arm} %ix86 x86_64 +%endif + +BuildRequires: cmake +BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(glib-2.0) +BuildRequires: pkgconfig(gobject-2.0) +BuildRequires: pkgconfig(capi-base-common) +BuildRequires: pkgconfig(sqlite3) +BuildRequires: python +Buildrequires: python-xml + +Requires(post): /sbin/ldconfig +Requires(postun): /sbin/ldconfig + +%description + +%package devel +Summary: A MTP library in Native API (Development) +Group: Network & Connectivity/Other +Requires: %{name} = %{version}-%{release} + +%description devel + +%prep +%setup -q + +%build +MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` + +cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} \ + -DLIB_INSTALL_DIR=%{_libdir} \ + -DFULLVER=%{version} \ + -DMAJORVER=${MAJORVER} + +make %{?jobs:-j%jobs} + +%install +rm -rf %{buildroot} +mkdir -p %{buildroot}/usr/share/license/mtp/ +cp -af %{_builddir}/%{name}-%{version}/LICENSE.APLv2 %{buildroot}/usr/share/license/mtp/ + +%make_install + +%post -p /sbin/ldconfig + +%postun -p /sbin/ldconfig + + +%files +%manifest capi-network-mtp.manifest +%{_libdir}/libcapi-network-mtp.so* +/usr/share/license/mtp/LICENSE.APLv2 + +%files devel +%{_includedir}/*.h +%{_libdir}/pkgconfig/*.pc +%{_libdir}/libcapi-network-mtp.so diff --git a/src/mtp.c b/src/mtp.c new file mode 100755 index 0000000..d1096a1 --- /dev/null +++ b/src/mtp.c @@ -0,0 +1,1027 @@ +/* +* Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. +* +* 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 +#include +#include +#include +#include + +#include + +#include "mtp.h" +#include "mtp_internal.h" +#include "mtp_db.h" +#include "mtp_debug.h" + +#include "mtp_gdbus_manager.h" +#include "mtp_gdbus_deviceinfo.h" +#include "mtp_gdbus_storageinfo.h" +#include "mtp_gdbus_objectinfo.h" + +int ref_count = 0; +bool __is_initialized = false; + +#define MTP_LOCK \ +do { \ + pthread_mutex_lock(&mutex); \ +} while (0); + +#define MTP_UNLOCK \ +do { \ + pthread_mutex_unlock(&mutex); \ +} while (0); + +static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; + +#define CHECK_INIT() \ +do { \ + MTP_LOCK; \ + { \ + if (__is_initialized == false) { \ + MTP_UNLOCK; \ + return MTP_ERROR_NOT_INITIALIZED; \ + } \ + } \ + MTP_UNLOCK; \ +} while (0); + +#define CHECK_SUPPORTED() \ +do { \ + { \ + if (__is_mtp_supported() == false) { \ + return MTP_ERROR_NOT_SUPPORTED; \ + } \ + } \ +} while (0); + +#define CHECK_ACTIVATED() \ +do { \ + { \ + if (__is_mtp_activated() == false) { \ + return MTP_ERROR_NOT_ACTIVATED; \ + } \ + } \ +} while (0); + +typedef enum { + MTP_PROPERTY_ASSOCIATION_DESC = 1, + MTP_PROPERTY_ASSOCIATION_TYPE, + MTP_PROPERTY_SIZE, + MTP_PROPERTY_DATA_CREATED, + MTP_PROPERTY_DATA_MODIFIED, + MTP_PROPERTY_FORMAT, + MTP_PROPERTY_IMAGE_FIX_DEPTH, + MTP_PROPERTY_IMAGE_FIX_WIDTH, + MTP_PROPERTY_IMAGE_FIX_HEIGHT, + MTP_PROPERTY_PARENT_OBJECT_HANDLE, + MTP_PROPERTY_STORAGE_ID, + MTP_PROPERTY_THUMBNAIL_SIZE, + MTP_PROPERTY_THUMBNAIL_FORMAT, + MTP_PROPERTY_THUMBNAIL_WIDTH, + MTP_PROPERTY_THUMBNAIL_HEIGHT, + MTP_PROPERTY_FILENAME, + MTP_PROPERTY_KEYWORDS +} mtp_property_e; + +static bool __is_mtp_supported() +{ + return true; +} + +static bool __is_mtp_activated() +{ + return true; +} + +/* Device Manager */ +int mtp_initialize(void) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + + /* precondition check end */ + + MTP_LOCK; + + if (__is_initialized == false) { + ret = mtp_gdbus_manager_initialize(); + mtp_db_init(); + __is_initialized = true; + } + ref_count++; + + MTP_UNLOCK; + + _END(); + + return ret; +} + +int mtp_get_device_list(mtp_device_list **dev_list) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + + /* precondition check end */ + + ret = mtp_gdbus_manager_get_device_list(dev_list); + + _END(); + + return ret; +} + +int mtp_get_device_handle(int bus_location, int *device_handle) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(bus_location == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_manager_get_device_handle(bus_location, device_handle); + + TC_PRT("mtp_handle %d", *device_handle); + + _END(); + + return ret; +} + +int mtp_get_storage_ids(int device_handle, int **storage_ids, int *storage_num) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_manager_get_storage_ids(device_handle, storage_ids, storage_num); + + TC_PRT("storage number %d", *storage_num); + + _END(); + + return ret; +} + +int mtp_get_object_handles(int device_handle, int storage_id, int format, + int parent_object_handle, int **object_handles, int *object_num) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + cond_expr_ret(storage_id == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_manager_get_object_handles(device_handle, + storage_id, format, parent_object_handle, object_handles, object_num); + + _END(); + + return ret; +} + +int mtp_delete_object(int device_handle, int object_handle) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + cond_expr_ret(object_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_manager_delete_object(device_handle, object_handle); + + _END(); + + return ret; +} + +int mtp_get_object(int device_handle, int object_handle, char *dest_path) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + cond_expr_ret(dest_path == NULL, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_manager_get_object(device_handle, object_handle, dest_path); + + _END(); + + return ret; +} + +int mtp_get_thumbnail(int device_handle, int object_handle, char *dest_path) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + cond_expr_ret(dest_path == NULL, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_manager_get_thumbnail(device_handle, object_handle, dest_path); + + _END(); + + return ret; +} + +int mtp_set_mtp_event_cb(mtp_event_cb callback, void *user_data) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + cond_expr_ret(callback == NULL, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_manager_set_event_cb(callback, user_data); + + _END(); + + return ret; +} + +int mtp_unset_mtp_event_cb(void) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + + /* precondition check end */ + + ret = mtp_gdbus_manager_unset_event_cb(); + + _END(); + + return ret; +} + +int mtp_deinitialize(void) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + + /* precondition check end */ + + MTP_LOCK; + + if (ref_count > 0) + ref_count--; + + if (__is_initialized == true && ref_count == 0) { + mtp_db_deinit(); + ret = mtp_gdbus_manager_deinitialize(); + __is_initialized = false; + } + + MTP_UNLOCK; + + _END(); + + return ret; +} + +/* Device Info */ +int mtp_deviceinfo_get_manufacturername(int device_handle, char **manufacturername) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_deviceinfo_get_manufacturername(device_handle, manufacturername); + + TC_PRT("manufacturername %s", *manufacturername); + + _END(); + + return ret; +} + +int mtp_deviceinfo_get_modelname(int device_handle, char **modelname) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_deviceinfo_get_modelname(device_handle, modelname); + + TC_PRT("modelname %s", *modelname); + + _END(); + + return ret; +} + +int mtp_deviceinfo_get_serialnumber(int device_handle, char **serialnumber) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_deviceinfo_get_serialnumber(device_handle, serialnumber); + + TC_PRT("serialnumber %s", *serialnumber); + + _END(); + + return ret; +} + +int mtp_deviceinfo_get_deviceversion(int device_handle, char **deviceversion) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_deviceinfo_get_deviceversion(device_handle, deviceversion); + + TC_PRT("deviceversion %s", *deviceversion); + + _END(); + + return ret; +} + +/* Storage Info */ +int mtp_storageinfo_get_description(int device_handle, int storage_id, char **description) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + cond_expr_ret(storage_id == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_storageinfo_get_description(device_handle, storage_id, description); + + TC_PRT("description %s", *description); + + _END(); + + return ret; +} + +int mtp_storageinfo_get_freespace(int device_handle, int storage_id, guint64 *freespace) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + cond_expr_ret(storage_id == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_storageinfo_get_freespace(device_handle, storage_id, freespace); + + TC_PRT("freespace %d", (int)*freespace); + + _END(); + + return ret; +} + +int mtp_storageinfo_get_maxcapacity(int device_handle, int storage_id, guint64 *maxcapacity) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + cond_expr_ret(storage_id == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_storageinfo_get_maxcapacity(device_handle, storage_id, maxcapacity); + + TC_PRT("maxcapacity %d", (int)*maxcapacity); + + _END(); + + return ret; +} + +int mtp_storageinfo_get_storagetype(int device_handle, int storage_id, int *storagetype) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + cond_expr_ret(storage_id == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_storageinfo_get_storagetype(device_handle, storage_id, storagetype); + + TC_PRT("storagetype %d", *storagetype); + + _END(); + + return ret; +} + +int mtp_storageinfo_get_volumeidentifier(int device_handle, int storage_id, char **volumeidentifier) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + cond_expr_ret(storage_id == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_storageinfo_get_volumeidentifier(device_handle, storage_id, volumeidentifier); + + TC_PRT("volumeidentifier %s", *volumeidentifier); + + _END(); + + return ret; +} + +/* Object Info */ +int mtp_objectinfo_get_parent_object_handle(int device_handle, int object_handle, + int *parent_object_handle) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_PARENT_OBJECT_HANDLE, parent_object_handle); + + TC_PRT("parent object id %d", *parent_object_handle); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_storage_id(int device_handle, int object_handle, + int *storage_id) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_STORAGE_ID, storage_id); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_association_desc(int device_handle, + int object_handle, int *asso_desc) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_ASSOCIATION_DESC, asso_desc); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_association_type(int device_handle, + int object_handle, int *asso_type) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_ASSOCIATION_TYPE, asso_type); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_size(int device_handle, int object_handle, int *size) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_SIZE, size); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_data_created(int device_handle, + int object_handle, int *data_created) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_DATA_CREATED, data_created); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_data_modified(int device_handle, + int object_handle, int *data_modified) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_DATA_MODIFIED, data_modified); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_format(int device_handle, int object_handle, int *format) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_FORMAT, format); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_image_pix_depth(int device_handle, + int object_handle, int *depth) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_IMAGE_FIX_DEPTH, depth); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_image_pix_width(int device_handle, + int object_handle, int *width) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_IMAGE_FIX_WIDTH, width); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_image_pix_height(int device_handle, + int object_handle, int *height) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_IMAGE_FIX_HEIGHT, height); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_thumbnail_size(int device_handle, + int object_handle, int *size) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_THUMBNAIL_SIZE, size); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_thumbnail_format(int device_handle, + int object_handle, int *format) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_THUMBNAIL_FORMAT, format); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_thumbnail_pix_height(int device_handle, + int object_handle, int *height) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_THUMBNAIL_HEIGHT, height); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_thumbnail_pix_width(int device_handle, + int object_handle, int *width) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property(device_handle, + object_handle, MTP_PROPERTY_THUMBNAIL_WIDTH, width); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_filename(int device_handle, + int object_handle, char **filename) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property_string(device_handle, + object_handle, MTP_PROPERTY_FILENAME, filename); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_keywords(int device_handle, + int object_handle, char **keywords) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_gdbus_objectinfo_get_property_string(device_handle, + object_handle, MTP_PROPERTY_KEYWORDS, keywords); + + _END(); + + return ret; +} + +int mtp_objectinfo_get_object_info(int device_handle, + int object_handle, mtp_object_info **object_info) +{ + int ret = MTP_ERROR_NONE; + + _BEGIN(); + + /* precondition check start */ + + CHECK_SUPPORTED(); + CHECK_INIT(); + CHECK_ACTIVATED(); + cond_expr_ret(device_handle == 0, MTP_ERROR_INVALID_PARAMETER); + + /* precondition check end */ + + ret = mtp_db_get_object_info(device_handle, object_handle, object_info); + + _END(); + + return ret; +} + diff --git a/src/mtp_db.c b/src/mtp_db.c new file mode 100755 index 0000000..84e518d --- /dev/null +++ b/src/mtp_db.c @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 "mtp_db.h" + +#define MTP_DB_LOCK \ + do { \ + pthread_mutex_lock(&mutex); \ + } while (0); + +#define MTP_DB_UNLOCK \ + do { \ + pthread_mutex_unlock(&mutex); \ + } while (0); + +static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; +static sqlite3 *db; +int ref_count; + +mtp_error_e mtp_db_init() +{ + int ret = MTP_ERROR_NONE; + int sql_ret; + + MTP_DB_LOCK; + + if (ref_count > 0) { + ref_count++; + } else if (db == NULL) { + sql_ret = sqlite3_open_v2(MTP_DB_FILE, &db, + SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL); + + if (sql_ret == SQLITE_OK) + ref_count++; + else + ret = MTP_ERROR_DB; + } + + MTP_DB_UNLOCK; + + return ret; +} + +mtp_error_e mtp_db_get_object_info(int device_handle, int object_handle, mtp_object_info** object_info) +{ + int ret = MTP_ERROR_NONE; + int sql_ret; + char *sql = NULL; + sqlite3_stmt *stmt = NULL; + + MTP_DB_LOCK; + + if (db == NULL) { + MTP_DB_UNLOCK; + return MTP_ERROR_DB; + } + + *object_info = (mtp_object_info *)malloc(sizeof(mtp_object_info)); + + sql = sqlite3_mprintf("SELECT * FROM %s WHERE device_handle=%d and object_handle=%d;", + MTP_DB_TABLE, device_handle, object_handle); + + if (sql != NULL && (*object_info) != NULL) { + sql_ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL); + if (stmt != NULL) { + sql_ret = sqlite3_step(stmt); + if (sql_ret == SQLITE_ROW) { + (*object_info)->StorageID = sqlite3_column_int(stmt, 2); + (*object_info)->ObjectFormat = sqlite3_column_int(stmt, 4); + (*object_info)->ProtectionStatus = sqlite3_column_int(stmt, 5); + (*object_info)->ObjectCompressedSize = sqlite3_column_int(stmt, 6); + (*object_info)->ThumbFormat = sqlite3_column_int(stmt, 7); + (*object_info)->ThumbCompressedSize = sqlite3_column_int(stmt, 8); + (*object_info)->ThumbPixWidth = sqlite3_column_int(stmt, 9); + (*object_info)->ThumbPixHeight = sqlite3_column_int(stmt, 10); + (*object_info)->ImagePixWidth = sqlite3_column_int(stmt, 11); + (*object_info)->ImagePixHeight = sqlite3_column_int(stmt, 12); + (*object_info)->ImageBitDepth = sqlite3_column_int(stmt, 13); + (*object_info)->ParentObject = sqlite3_column_int(stmt, 14); + (*object_info)->AssociationType = sqlite3_column_int(stmt, 15); + (*object_info)->AssociationDesc = sqlite3_column_int(stmt, 16); + (*object_info)->SequenceNumber = sqlite3_column_int(stmt, 17); + (*object_info)->Filename = g_strdup((const char*)sqlite3_column_text(stmt, 18)); + (*object_info)->CaptureDate = sqlite3_column_int(stmt, 19); + (*object_info)->ModificationDate = sqlite3_column_int(stmt, 20); + (*object_info)->Keywords = NULL; + } else { + ret = MTP_ERROR_DB; + } + } else { + ret = MTP_ERROR_DB; + } + } else { + ret = MTP_ERROR_DB; + } + + if (stmt != NULL) + sqlite3_finalize(stmt); + + if (sql != NULL) + sqlite3_free(sql); + + MTP_DB_UNLOCK; + + return ret; +} + +mtp_error_e mtp_db_deinit() +{ + int ret = MTP_ERROR_NONE; + int sql_ret; + + MTP_DB_LOCK; + + if (ref_count > 0) + ref_count--; + + if (db != NULL && ref_count == 0) { + sql_ret = sqlite3_close(db); + + if (sql_ret != SQLITE_OK) + ret = MTP_ERROR_DB; + + db = NULL; + } + + MTP_DB_UNLOCK; + + return ret; +} diff --git a/src/mtp_gdbus_deviceinfo.c b/src/mtp_gdbus_deviceinfo.c new file mode 100755 index 0000000..eff5d5b --- /dev/null +++ b/src/mtp_gdbus_deviceinfo.c @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 "mtp_gdbus_deviceinfo.h" + +mtpgdbuslibDeviceinfo *deviceinfo_proxy = NULL; + +void mtp_gdbus_deviceinfo_proxy_init(void) +{ + deviceinfo_proxy = mtp_gdbuslib_deviceinfo_proxy_new_for_bus_sync( + G_BUS_TYPE_SYSTEM, + G_DBUS_PROXY_FLAGS_NONE, + MTP_DBUS_SERVICE, + MTP_DBUS_DEVICEINFO_PATH, + NULL, + NULL); +} + +void mtp_gdbus_deviceinfo_proxy_deinit(void) +{ + deviceinfo_proxy = NULL; +} + +mtp_error_e mtp_gdbus_deviceinfo_get_manufacturername(int device_handle, char **manufacturername) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (deviceinfo_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_deviceinfo_call_get_manufacturername_sync( + deviceinfo_proxy, + device_handle, + manufacturername, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + g_error_free(error); + } + + return result; +} + +mtp_error_e mtp_gdbus_deviceinfo_get_modelname(int device_handle, char **modelname) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (deviceinfo_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_deviceinfo_call_get_modelname_sync( + deviceinfo_proxy, + device_handle, + modelname, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + g_error_free(error); + } + + return result; +} + +mtp_error_e mtp_gdbus_deviceinfo_get_serialnumber(int device_handle, char **serialnumber) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (deviceinfo_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_deviceinfo_call_get_serialnumber_sync( + deviceinfo_proxy, + device_handle, + serialnumber, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + g_error_free(error); + } + + return result; +} + +mtp_error_e mtp_gdbus_deviceinfo_get_deviceversion(int device_handle, char **deviceversion) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (deviceinfo_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_deviceinfo_call_get_deviceversion_sync( + deviceinfo_proxy, + device_handle, + deviceversion, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + g_error_free(error); + } + + return result; +} + diff --git a/src/mtp_gdbus_manager.c b/src/mtp_gdbus_manager.c new file mode 100755 index 0000000..ca4b603 --- /dev/null +++ b/src/mtp_gdbus_manager.c @@ -0,0 +1,348 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 "mtp_gdbus_manager.h" +#include "mtp_gdbus_objectinfo.h" +#include "mtp_gdbus_deviceinfo.h" +#include "mtp_gdbus_storageinfo.h" + +mtpgdbuslibManager *manager_proxy = NULL; +mtp_event_cb event_callback; +void *event_user_data; + +static void __mtp_event_cb(mtpgdbuslibManager *object, + gint event, gint arg1, gpointer user_data) +{ + if (event_callback) + event_callback(event, arg1, event_user_data); +} + +static void __manager_proxy_init(void) +{ + GError *error = NULL; + + manager_proxy = mtp_gdbuslib_manager_proxy_new_for_bus_sync( + G_BUS_TYPE_SYSTEM, + G_DBUS_PROXY_FLAGS_NONE, + MTP_DBUS_SERVICE, + MTP_DBUS_MANAGER_PATH, + NULL, + &error); + + g_signal_connect(manager_proxy, "mtp-event", G_CALLBACK(__mtp_event_cb), NULL); +} + +static void __manager_proxy_deinit(void) +{ + manager_proxy = NULL; +} + +mtp_error_e mtp_gdbus_manager_set_event_cb(mtp_event_cb callback, void *user_data) +{ + event_callback = callback; + event_user_data = user_data; + + return MTP_ERROR_NONE; +} + +mtp_error_e mtp_gdbus_manager_unset_event_cb(void) +{ + event_callback = NULL; + event_user_data = NULL; + + return MTP_ERROR_NONE; +} + +mtp_error_e mtp_gdbus_manager_initialize(void) +{ + mtp_error_e result = MTP_ERROR_NONE; + + __manager_proxy_init(); + mtp_gdbus_deviceinfo_proxy_init(); + mtp_gdbus_storageinfo_proxy_init(); + mtp_gdbus_objectinfo_proxy_init(); + + if (manager_proxy == NULL) + result = MTP_ERROR_GENERAL; + + return result; +} + +mtp_error_e mtp_gdbus_manager_get_device_list(mtp_device_list **dev_list) +{ + int dev_count; + GVariant *va = NULL; + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (manager_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_manager_call_get_device_list_sync( + manager_proxy, + &dev_count, + &va, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + + g_error_free(error); + return result; + } + + if (dev_count != 0 && (g_variant_n_children(va) == dev_count)) { + GVariantIter *iter = NULL, *iter_row = NULL; + GVariant *key_value; + const gchar *key; + guint i = 0; + + *dev_list = g_new(mtp_device_list, 1); + (*dev_list)->device_num = dev_count; + (*dev_list)->devices = g_new(mtp_device, dev_count); + + g_variant_get(va, "aa{sv}", &iter); + while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { + while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) { + if (g_strcmp0(key, "model_name") == 0) { + ((*dev_list)->devices)[i].model_name = + g_strdup(g_variant_get_string(key_value, NULL)); + } else if (g_strcmp0(key, "bus_location") == 0) { + ((*dev_list)->devices)[i].bus_location = g_variant_get_int32(key_value); + } + } + i++; + g_variant_iter_free(iter_row); + } + g_variant_iter_free(iter); + } else { + result = MTP_ERROR_NO_DEVICE; + } + + g_variant_unref(va); + + return result; +} + +mtp_error_e mtp_gdbus_manager_get_device_handle(int bus_location, int *device_handle) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (manager_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_manager_call_get_device_handle_sync( + manager_proxy, + bus_location, + device_handle, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + + g_error_free(error); + } + + return result; +} + +mtp_error_e mtp_gdbus_manager_get_storage_ids(int device_handle, + int **storage_ids, int *storage_num) +{ + GVariant *va = NULL; + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (manager_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_manager_call_get_storage_ids_sync( + manager_proxy, + device_handle, + storage_num, + &va, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + + g_error_free(error); + return result; + } + + if (*storage_num != 0 && (g_variant_n_children(va) == *storage_num)) { + GVariantIter *iter = NULL, *iter_row = NULL; + GVariant *key_value; + const gchar *key; + guint i = 0; + + *storage_ids = g_new(int, *storage_num); + + g_variant_get(va, "aa{sv}", &iter); + while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { + while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) { + if (g_strcmp0(key, "storage_id") == 0) + (*storage_ids)[i] = g_variant_get_int32(key_value); + } + i++; + g_variant_iter_free(iter_row); + } + g_variant_iter_free(iter); + } + + g_variant_unref(va); + + return result; +} + +mtp_error_e mtp_gdbus_manager_get_object_handles(int device_handle, + int storage_id, int format, int parent_object_handle, int **object_handles, int *object_num) +{ + GVariant *va = NULL; + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (manager_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_manager_call_get_object_handles_sync( + manager_proxy, + device_handle, + storage_id, + format, + parent_object_handle, + object_num, + &va, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + + g_error_free(error); + return result; + } + + if (*object_num != 0 && (g_variant_n_children(va) == *object_num)) { + GVariantIter *iter = NULL, *iter_row = NULL; + GVariant *key_value; + const gchar *key; + guint i = 0; + + *object_handles = g_new(int, *object_num); + + g_variant_get(va, "aa{sv}", &iter); + while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { + while (g_variant_iter_loop(iter_row, "{sv}", &key, &key_value)) { + if (g_strcmp0(key, "object_handle") == 0) + (*object_handles)[i] = g_variant_get_int32(key_value); + } + i++; + g_variant_iter_free(iter_row); + } + g_variant_iter_free(iter); + } + + g_variant_unref(va); + + return result; +} + +mtp_error_e mtp_gdbus_manager_delete_object(int device_handle, + int object_handle) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (manager_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_manager_call_delete_object_sync( + manager_proxy, + device_handle, + object_handle, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + + g_error_free(error); + } + + return result; +} + +mtp_error_e mtp_gdbus_manager_get_object(int device_handle, + int object_handle, char *dest_path) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (manager_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_manager_call_get_object_sync( + manager_proxy, + device_handle, + object_handle, + dest_path, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + + g_error_free(error); + } + + return result; +} + +mtp_error_e mtp_gdbus_manager_get_thumbnail(int device_handle, + int object_handle, char *dest_path) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (manager_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_manager_call_get_thumbnail_sync( + manager_proxy, + device_handle, + object_handle, + dest_path, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + + g_error_free(error); + } + + return result; +} + +mtp_error_e mtp_gdbus_manager_deinitialize(void) +{ + mtp_error_e result = MTP_ERROR_NONE; + + __manager_proxy_deinit(); + mtp_gdbus_deviceinfo_proxy_deinit(); + mtp_gdbus_storageinfo_proxy_deinit(); + mtp_gdbus_objectinfo_proxy_deinit(); + + return result; +} diff --git a/src/mtp_gdbus_objectinfo.c b/src/mtp_gdbus_objectinfo.c new file mode 100755 index 0000000..38077fb --- /dev/null +++ b/src/mtp_gdbus_objectinfo.c @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 "mtp_gdbus_objectinfo.h" + +mtpgdbuslibObjectinfo *objectinfo_proxy = NULL; + +void mtp_gdbus_objectinfo_proxy_init(void) +{ + objectinfo_proxy = mtp_gdbuslib_objectinfo_proxy_new_for_bus_sync( + G_BUS_TYPE_SYSTEM, + G_DBUS_PROXY_FLAGS_NONE, + MTP_DBUS_SERVICE, + MTP_DBUS_OBJECTINFO_PATH, + NULL, + NULL); +} + +void mtp_gdbus_objectinfo_proxy_deinit(void) +{ + objectinfo_proxy = NULL; +} + +int mtp_gdbus_objectinfo_get_property(int device_handle, + int object_handle, int property, int *property_value) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (objectinfo_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_objectinfo_call_get_property_sync( + objectinfo_proxy, + device_handle, + object_handle, + property, + property_value, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + g_error_free(error); + } + + return result; +} + +int mtp_gdbus_objectinfo_get_property_string(int device_handle, + int object_handle, int property, char **property_value) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (objectinfo_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_objectinfo_call_get_property_string_sync( + objectinfo_proxy, + device_handle, + object_handle, + property, + property_value, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + g_error_free(error); + } + + return result; +} + diff --git a/src/mtp_gdbus_storageinfo.c b/src/mtp_gdbus_storageinfo.c new file mode 100755 index 0000000..b8ab9f6 --- /dev/null +++ b/src/mtp_gdbus_storageinfo.c @@ -0,0 +1,155 @@ +/* + * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd. + * + * 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 "mtp_gdbus_storageinfo.h" + +mtpgdbuslibStorageinfo *storageinfo_proxy = NULL; + +void mtp_gdbus_storageinfo_proxy_init(void) +{ + storageinfo_proxy = mtp_gdbuslib_storageinfo_proxy_new_for_bus_sync( + G_BUS_TYPE_SYSTEM, + G_DBUS_PROXY_FLAGS_NONE, + MTP_DBUS_SERVICE, + MTP_DBUS_STORAGEINFO_PATH, + NULL, + NULL); +} + +void mtp_gdbus_storageinfo_proxy_deinit(void) +{ + storageinfo_proxy = NULL; +} + +mtp_error_e mtp_gdbus_storageinfo_get_description(int device_handle, + int storage_id, char **description) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (storageinfo_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_storageinfo_call_get_description_sync( + storageinfo_proxy, + device_handle, + storage_id, + description, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + g_error_free(error); + } + + return result; +} + +mtp_error_e mtp_gdbus_storageinfo_get_freespace(int device_handle, + int storage_id, guint64 *freespace) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (storageinfo_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_storageinfo_call_get_free_space_sync( + storageinfo_proxy, + device_handle, + storage_id, + freespace, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + g_error_free(error); + } + + return result; +} + +mtp_error_e mtp_gdbus_storageinfo_get_maxcapacity(int device_handle, + int storage_id, guint64 *maxcapacity) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (storageinfo_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_storageinfo_call_get_max_capacity_sync( + storageinfo_proxy, + device_handle, + storage_id, + maxcapacity, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + g_error_free(error); + } + + return result; +} + +mtp_error_e mtp_gdbus_storageinfo_get_storagetype(int device_handle, + int storage_id, int *storagetype) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (storageinfo_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_storageinfo_call_get_storage_type_sync( + storageinfo_proxy, + device_handle, + storage_id, + storagetype, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + g_error_free(error); + } + + return result; +} + +mtp_error_e mtp_gdbus_storageinfo_get_volumeidentifier(int device_handle, + int storage_id, char **volumeidentifier) +{ + mtp_error_e result = MTP_ERROR_NONE; + GError *error = NULL; + + if (storageinfo_proxy == NULL) + return MTP_ERROR_GENERAL; + + if (mtp_gdbuslib_storageinfo_call_get_volume_identifier_sync( + storageinfo_proxy, + device_handle, + storage_id, + volumeidentifier, + &result, + NULL, + &error) == FALSE) { + result = MTP_ERROR_IO_ERROR; + g_error_free(error); + } + + return result; +} diff --git a/src/mtp_gdbuslib.xml b/src/mtp_gdbuslib.xml new file mode 100755 index 0000000..45afda8 --- /dev/null +++ b/src/mtp_gdbuslib.xml @@ -0,0 +1,138 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt new file mode 100755 index 0000000..474d37d --- /dev/null +++ b/test/CMakeLists.txt @@ -0,0 +1,18 @@ +SET(fw_test "${fw_name}-test") + +INCLUDE(FindPkgConfig) +pkg_check_modules(${fw_test} REQUIRED dlog glib-2.0) +FOREACH(flag ${${fw_test}_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") + MESSAGE(${flag}) +ENDFOREACH() + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Wall") + +aux_source_directory(. sources) +FOREACH(src ${sources}) + GET_FILENAME_COMPONENT(src_name ${src} NAME_WE) + MESSAGE("${src_name}") + ADD_EXECUTABLE(${src_name} ${src}) + TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS}) +ENDFOREACH() diff --git a/test/mtp_unit_test.c b/test/mtp_unit_test.c new file mode 100755 index 0000000..5aa8377 --- /dev/null +++ b/test/mtp_unit_test.c @@ -0,0 +1,1254 @@ +#include +#include +#include +#include +#include +#include + +#include +#include + +#define BUFFER_LEN 100 +#define TEST_CASE_MAX 39 +#define TEST_LIST_MAX 20 + +#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args) +#define TC_PRT(format, args...) PRT(format"\n", ##args) + +#define BEGIN() TC_PRT("BEGIN >>>>"); +#define END() TC_PRT("END <<<<"); + +static int handle; +static mtp_device_list* dev_list; + +static int strg_handle = 0; +static int* strg_list; + +static int obj_handle = 0; +static int* obj_list; +int obj_count; + +GMainLoop *main_loop = NULL; + +typedef struct { + const char *tc_name; + int tc_code; + int (*tc_func)(void); +} tc_table_t; + + +static bool test_get_user_int(const char *msg, int *num) +{ + if (msg == NULL || num == NULL) + return false; + + int rv; + char buf[32] = { 0, }; + printf("%s\n", msg); + rv = read(0, buf, 32); + + if (rv < 0 || *buf == 0 || *buf == '\n' || *buf == '\r') + return false; + + *num = atoi(buf); + return true; +} + +static bool test_get_user_string(const char *msg, char *buf, int buf_size) +{ + if (msg == NULL || buf == NULL || buf_size < 2) + return false; + + int rv; + printf("%s\n", msg); + memset(buf, 0, buf_size); + rv = read(0, buf, buf_size - 1); + + if (rv < 0 || buf[0] == '\0' || buf[0] == '\n' || buf[0] == '\r') { + buf[0] = '\0'; + return false; + } + + if (rv >= 0) + buf[rv] = '\0'; + + return true; +} + +static char *test_filetype_to_string(int type) +{ + switch (type) { + case MTP_FILETYPE_FOLDER: return "MTP_FILETYPE_FOLDER"; + case MTP_FILETYPE_WAV: return "MTP_FILETYPE_WAV"; + case MTP_FILETYPE_MP3: return "MTP_FILETYPE_MP3"; + case MTP_FILETYPE_WMA: return "MTP_FILETYPE_WMA"; + case MTP_FILETYPE_OGG: return "MTP_FILETYPE_OGG"; + case MTP_FILETYPE_AUDIBLE: return "MTP_FILETYPE_AUDIBLE"; + case MTP_FILETYPE_MP4: return "MTP_FILETYPE_MP4"; + case MTP_FILETYPE_UNDEF_AUDIO: return "MTP_FILETYPE_UNDEF_AUDIO"; + case MTP_FILETYPE_WMV: return "MTP_FILETYPE_WMV"; + case MTP_FILETYPE_AVI: return "MTP_FILETYPE_AVI"; + case MTP_FILETYPE_MPEG: return "MTP_FILETYPE_MPEG"; + case MTP_FILETYPE_ASF: return "MTP_FILETYPE_ASF"; + case MTP_FILETYPE_QT: return "MTP_FILETYPE_QT"; + case MTP_FILETYPE_UNDEF_VIDEO: return "MTP_FILETYPE_UNDEF_VIDEO"; + case MTP_FILETYPE_JPEG: return "MTP_FILETYPE_JPEG"; + case MTP_FILETYPE_JFIF: return "MTP_FILETYPE_JFIF"; + case MTP_FILETYPE_TIFF: return "MTP_FILETYPE_TIFF"; + case MTP_FILETYPE_BMP: return "MTP_FILETYPE_BMP"; + case MTP_FILETYPE_GIF: return "MTP_FILETYPE_GIF"; + case MTP_FILETYPE_PICT: return "MTP_FILETYPE_PICT"; + case MTP_FILETYPE_PNG: return "MTP_FILETYPE_PNG"; + case MTP_FILETYPE_VCALENDAR1: return "MTP_FILETYPE_VCALENDAR1"; + case MTP_FILETYPE_VCALENDAR2: return "MTP_FILETYPE_VCALENDAR2"; + case MTP_FILETYPE_VCARD2: return "MTP_FILETYPE_VCARD2"; + case MTP_FILETYPE_VCARD3: return "MTP_FILETYPE_VCARD3"; + case MTP_FILETYPE_WINDOWSIMAGEFORMAT: return "MTP_FILETYPE_WINDOWSIMAGEFORMAT"; + case MTP_FILETYPE_WINEXEC: return "MTP_FILETYPE_WINEXEC"; + case MTP_FILETYPE_TEXT: return "MTP_FILETYPE_TEXT"; + case MTP_FILETYPE_HTML: return "MTP_FILETYPE_HTML"; + case MTP_FILETYPE_FIRMWARE: return "MTP_FILETYPE_FIRMWARE"; + case MTP_FILETYPE_AAC: return "MTP_FILETYPE_AAC"; + case MTP_FILETYPE_MEDIACARD: return "MTP_FILETYPE_MEDIACARD"; + case MTP_FILETYPE_FLAC: return "MTP_FILETYPE_FLAC"; + case MTP_FILETYPE_MP2: return "MTP_FILETYPE_MP2"; + case MTP_FILETYPE_M4A: return "MTP_FILETYPE_M4A"; + case MTP_FILETYPE_DOC: return "MTP_FILETYPE_DOC"; + case MTP_FILETYPE_XML: return "MTP_FILETYPE_XML"; + case MTP_FILETYPE_XLS: return "MTP_FILETYPE_XLS"; + case MTP_FILETYPE_PPT: return "MTP_FILETYPE_PPT"; + case MTP_FILETYPE_MHT: return "MTP_FILETYPE_MHT"; + case MTP_FILETYPE_JP2: return "MTP_FILETYPE_JP2"; + case MTP_FILETYPE_JPX: return "MTP_FILETYPE_JPX"; + case MTP_FILETYPE_ALBUM: return "MTP_FILETYPE_ALBUM"; + case MTP_FILETYPE_PLAYLIST: return "MTP_FILETYPE_PLAYLIST"; + case MTP_FILETYPE_UNKNOWN: return "MTP_FILETYPE_UNKNOWN"; + default: return "Not Supported type!!!"; + } +} + +int manager_test_initialize(void) +{ + int ret = 0; + + BEGIN(); + + ret = mtp_initialize(); + + if (ret == MTP_ERROR_NONE) + TC_PRT("Initialize successful"); + else + TC_PRT("Initialize failed, ret [%d]", ret); + + END(); + return ret; +} + +int manager_test_get_device_list(void) +{ + int ret = 0; + int i; + BEGIN(); + + ret = mtp_get_device_list(&dev_list); + + if (ret == MTP_ERROR_NONE) { + TC_PRT("ret[%d]: device_num[%d]", ret, dev_list->device_num); + + for (i = 0; i < dev_list->device_num; i++) { + TC_PRT("device bus_location[%d] model_name[%s]", + dev_list->devices[i].bus_location, dev_list->devices[i].model_name); + } + } else { + TC_PRT("get device list failed, ret[%d]", ret); + } + + END(); + return ret; +} + +int manager_test_get_device_handle(void) +{ + int ret = 0; + int input_int = 0; + int bus_location = 0; + BEGIN(); + + if (dev_list->device_num == 0) { + TC_PRT("device is not exist!!!"); + END(); + return -1; + } + + input_int = dev_list->devices[0].bus_location; + + if (dev_list->device_num > 1) { + if (!test_get_user_int("==> Input Bus_location No :", &input_int)) + TC_PRT("select first bus[%d]", input_int); + } + + bus_location = input_int; + + ret = mtp_get_device_handle(bus_location, &handle); + TC_PRT("ret[%d]: 1st device handle[%d]", ret, handle); + + END(); + return ret; +} + +int manager_test_get_storage_ids(void) +{ + int ret = 0; + int i; + int count = 0; + int input_int = 0; + BEGIN(); + + ret = mtp_get_storage_ids(handle, &strg_list, &count); + TC_PRT("ret[%d]: storage_num[%d]", ret, count); + + if (count == 0) { + TC_PRT("storage is not exist!!!"); + END(); + return -1; + } + + for (i = 0; i < count; i++) + TC_PRT("storage handle[%d]", strg_list[i]); + + input_int = strg_list[0]; + + if (count > 1) { + if (!test_get_user_int("==> Input Storage Handle :", &input_int)) + TC_PRT("select first storage[%d]", strg_list[0]); + } + + strg_handle = input_int; + TC_PRT("selected storage handle[%d]", strg_handle); + + END(); + return ret; +} + +int manager_test_get_object_handles(void) +{ + int ret = 0; + int i; + int input_int = 0; + int *folder_list; + int folder_count = 0; + int *file_list; + int file_count = 0; + int format = MTP_FILETYPE_FOLDER; + char *filename = NULL; + int folder_max = 0; + int file_max = 0; + int list_max = 0; + BEGIN(); + + ret = mtp_get_object_handles(handle, strg_handle, MTP_FILETYPE_FOLDER, obj_handle, &folder_list, &folder_count); + TC_PRT("ret[%d]: total folder_count[%d]", ret, folder_count); + + folder_max = (folder_count < TEST_LIST_MAX) ? folder_count : TEST_LIST_MAX; + + for (i = 0; i < folder_max; i++) { + ret = mtp_objectinfo_get_filename(handle, folder_list[i], &filename); + ret = mtp_objectinfo_get_format(handle, folder_list[i], &format); + TC_PRT("ret[%d]: object id[%d] - filename[%s], format[%s]", + ret, folder_list[i], filename, test_filetype_to_string(format)); + } + + ret = mtp_get_object_handles(handle, strg_handle, MTP_FILETYPE_JPEG, obj_handle, &file_list, &file_count); + TC_PRT("ret[%d]: total file_count[%d]", ret, file_count); + + file_max = (file_count < TEST_LIST_MAX) ? file_count : TEST_LIST_MAX; + + for (i = 0; i < file_max; i++) { + ret = mtp_objectinfo_get_filename(handle, file_list[i], &filename); + ret = mtp_objectinfo_get_format(handle, file_list[i], &format); + TC_PRT("ret[%d]: object id[%d] - filename[%s], format[%s]", + ret, file_list[i], filename, test_filetype_to_string(format)); + } + + if (!test_get_user_int("==> Select Object Type(FOLDER:0, JPEG:14)" + " - (Enter for skip) :", &input_int)) { + TC_PRT("select default : folder[%d]", input_int); + } + + ret = mtp_get_object_handles(handle, strg_handle, input_int, obj_handle, &obj_list, &obj_count); + + TC_PRT("ret[%d]: total object_num[%d]", ret, obj_count); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_filename(handle, obj_list[i], &filename); + ret = mtp_objectinfo_get_format(handle, obj_list[i], &format); + TC_PRT("ret[%d]: object id[%d] - filename[%s], format[%s]", + ret, obj_list[i], filename, test_filetype_to_string(format)); + } + + if (input_int == MTP_FILETYPE_FOLDER) { + if (!test_get_user_int("==> Input Object ID :", &obj_handle)) { + TC_PRT("invalid input !!![%d]", obj_handle); + obj_handle = 0; + END(); + return -1; + } + TC_PRT("selected object id[%d]", obj_handle); + TC_PRT("===== Object List - Folder ====="); + } else { + TC_PRT("===== Object List - JPEG ====="); + } + + END(); + return ret; +} + +int manager_test_delete_object(void) +{ + int ret = 0; + int i; + int input_int = 0; + int format = MTP_FILETYPE_JPEG; + char *filename = NULL; + int list_max = 0; + BEGIN(); + + TC_PRT("total object_num[%d]", obj_count); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_filename(handle, obj_list[i], &filename); + ret = mtp_objectinfo_get_format(handle, obj_list[i], &format); + TC_PRT("ret[%d]: object id[%d] - filename[%s], format[%s]", + ret, obj_list[i], filename, test_filetype_to_string(format)); + } + + if (!test_get_user_int("==> Input Object ID :", &input_int)) { + TC_PRT("Invalid Input !!![%d]", input_int); + END(); + return -1; + } + + ret = mtp_delete_object(handle, input_int); + TC_PRT("ret[%d]: input id[%d]", ret, input_int); + + END(); + return ret; +} + +int manager_test_get_object(void) +{ + int ret = 0; + int i; + int input_int = 0; + int format = MTP_FILETYPE_JPEG; + char *filename = NULL; + char filepath[100] = {0,}; + int list_max = 0; + BEGIN(); + + TC_PRT("total object_num[%d]", obj_count); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_filename(handle, obj_list[i], &filename); + ret = mtp_objectinfo_get_format(handle, obj_list[i], &format); + TC_PRT("ret[%d]: object id[%d] - filename[%s], format[%s]", + ret, obj_list[i], filename, test_filetype_to_string(format)); + } + + if (!test_get_user_int("==> Input Object ID :", &input_int)) { + TC_PRT("Invalid Input !!![%d]", input_int); + END(); + return -1; + } + + snprintf(filepath, 100, "/opt/usr/media/Downloads/JpegObject_%d.jpg", input_int); + + ret = mtp_get_object(handle, input_int, filepath); + TC_PRT("ret[%d]: input id[%d]", ret, input_int); + + END(); + return ret; +} + + +int manager_test_get_thumbnail(void) +{ + int i; + int ret = 0; + int input_int = 0; + char input_str[50] = {0, }; + char filepath[100] = {0,}; + int format = MTP_FILETYPE_JPEG; + char *filename = NULL; + int list_max = 0; + BEGIN(); + + TC_PRT("total object_num[%d]", obj_count); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_filename(handle, obj_list[i], &filename); + ret = mtp_objectinfo_get_format(handle, obj_list[i], &format); + TC_PRT("ret[%d]: object id[%d] - filename[%s], format[%s]", + ret, obj_list[i], filename, test_filetype_to_string(format)); + } + + if (!test_get_user_int("==> Input JPEG ID :", &input_int)) { + TC_PRT("Invalid Input !!![%d]", input_int); + END(); + return -1; + } + + /* String Input Test */ + if (test_get_user_string("Input Dest File Name(ex - thumbnail or thum)" + " - (Enter for skip) :", input_str, 50)) { + g_strstrip(input_str); + } else { + TC_PRT("Invalid Input !!![%s]", input_str); + END(); + return -1; + } + + snprintf(filepath, 100, "/opt/usr/media/Downloads/%s_%d.jpg", input_str, input_int); + + ret = mtp_get_thumbnail(handle, input_int, filepath); + TC_PRT("ret[%d]: input jpeg id[%d], input file path[%s]", ret, input_int, filepath); + + END(); + return ret; +} + +int manager_test_deinitialize(void) +{ + int ret = 0; + BEGIN(); + + ret = mtp_deinitialize(); + TC_PRT("ret[%d] : deinitialize", ret); + + END(); + return ret; +} + +int deviceinfo_test_get_manufacturername(void) +{ + int ret = 0; + char *name = NULL; + BEGIN(); + + ret = mtp_deviceinfo_get_manufacturername(handle, &name); + TC_PRT("ret[%d]: manufacturername[%s]", ret, name); + + END(); + return ret; +} + +int deviceinfo_test_get_modelname(void) +{ + int ret = 0; + char *name = NULL; + BEGIN(); + + ret = mtp_deviceinfo_get_modelname(handle, &name); + TC_PRT("ret[%d]: modelname[%s]", ret, name); + + END(); + return ret; +} + +int deviceinfo_test_get_serialnumber(void) +{ + int ret = 0; + char *name = NULL; + BEGIN(); + + ret = mtp_deviceinfo_get_serialnumber(handle, &name); + TC_PRT("ret[%d]: serialnumber[%s]", ret, name); + + END(); + return ret; +} + +int deviceinfo_test_get_deviceversion(void) +{ + int ret = 0; + char *name = NULL; + BEGIN(); + + ret = mtp_deviceinfo_get_deviceversion(handle, &name); + TC_PRT("ret[%d]: deviceversion[%s]", ret, name); + + END(); + return ret; +} + + +int storageinfo_test_get_description(void) +{ + int ret = 0; + char *name = NULL; + BEGIN(); + + ret = mtp_storageinfo_get_description(handle, strg_handle, &name); + TC_PRT("ret[%d]: description[%s]", ret, name); + + END(); + return ret; +} + +int storageinfo_test_get_freespace(void) +{ + int ret = 0; + guint64 value = 0; + BEGIN(); + + ret = mtp_storageinfo_get_freespace(handle, strg_handle, &value); + TC_PRT("ret[%d]: freespace[%d]", ret, (int)value); + + END(); + return ret; +} + +int storageinfo_test_get_maxcapacity(void) +{ + int ret = 0; + guint64 value = 0; + BEGIN(); + + ret = mtp_storageinfo_get_maxcapacity(handle, strg_handle, &value); + TC_PRT("ret[%d]: maxcapacity[%d]", ret, (int)value); + + END(); + return ret; +} + +int storageinfo_test_get_storagetype(void) +{ + int ret = 0; + int value = 0; + BEGIN(); + + ret = mtp_storageinfo_get_storagetype(handle, strg_handle, &value); + TC_PRT("ret[%d]: storagetype[%d]", ret, value); + + END(); + return ret; +} + +int storageinfo_test_get_volumeidentifier(void) +{ + int ret = 0; + char *name = NULL; + BEGIN(); + + ret = mtp_storageinfo_get_volumeidentifier(handle, strg_handle, &name); + TC_PRT("ret[%d]: volumeidentifier[%s]", ret, name); + + END(); + return ret; +} + +int objectinfo_test_get_association_desc(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_association_desc(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] association_desc[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_association_type(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_association_type(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] association_type[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_size(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_size(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] size[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_parent_object_handle(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_parent_object_handle(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] parent_object_handle[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_storage_id(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_storage_id(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] storage_id[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_data_created(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_data_created(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] data_created[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_data_modified(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_data_modified(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] data_modified[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_format(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_format(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] format[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_image_pix_depth(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_image_pix_depth(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] image_pix_depth[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_image_pix_width(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_image_pix_width(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] image_pix_width[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_image_pix_height(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_image_pix_height(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] image_pix_height[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_thumbnail_size(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_thumbnail_size(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] thumbnail_size[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_thumbnail_format(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_thumbnail_format(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] thumbnail_format[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_thumbnail_pix_height(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_thumbnail_pix_height(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] thumbnail_pix_height[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_thumbnail_pix_width(void) +{ + int i; + int ret = 0; + int value = 0; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_thumbnail_pix_width(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] thumbnail_pix_width[%d]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_filename(void) +{ + int i; + int ret = 0; + char *value = NULL; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_filename(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] filename[%s]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int objectinfo_test_get_keywords(void) +{ + int i; + int ret = 0; + char *value = NULL; + int list_max = 0; + BEGIN(); + + list_max = (obj_count < TEST_LIST_MAX) ? obj_count : TEST_LIST_MAX; + + for (i = 0; i < list_max; i++) { + ret = mtp_objectinfo_get_keywords(handle, obj_list[i], &value); + TC_PRT("ret[%d]: object id[%d] keywords[%s]", ret, obj_list[i], value); + } + + END(); + return ret; +} + +int application_test_get_image_from_DCIM(void) +{ + int ret = 0; + int i; + int format = MTP_FILETYPE_FOLDER; + int *object_list; + int object_count = 0; + int *object_list2; + int object_count2 = 0; + char filepath[100] = {0,}; + char *filename = NULL; + int selected_id = 0; + int input_object_id = 0; + int input_object_id2 = 0; + BEGIN(); + + while (true) { + TC_PRT("storage_handle : %d", strg_handle); + + if (!test_get_user_int("==> 1. Select Object type (FOLDER:0, JPEG:14, BMP:17)" + " - (Enter for skip) :", &input_object_id2)) { + TC_PRT("Invalid Input !!! [%d]", input_object_id2); + break; + } + + ret = mtp_get_object_handles(handle, (strg_handle > 0 ? strg_handle : 0), input_object_id2, selected_id, &object_list, &object_count); + + TC_PRT("Total object_num [%d]", object_count); + + for (i = 0; i < object_count; i++) { + TC_PRT("object handle %d", object_list[i]); + + ret = mtp_objectinfo_get_filename(handle, object_list[i], &filename); + ret = mtp_objectinfo_get_format(handle, object_list[i], &format); + + TC_PRT("ret : %d", ret); + TC_PRT("Folder object id %d - filename[%s], format[%s]\n", object_list[i], filename, test_filetype_to_string(format)); + } + + if (!test_get_user_int("==> 1. Input Folder Object ID (Enter for exit):", &input_object_id)) { + TC_PRT("input_object_id : %d", input_object_id); + g_free(object_list); + break; + } + + selected_id = input_object_id; + + ret = mtp_objectinfo_get_filename(handle, selected_id, &filename); + ret = mtp_objectinfo_get_format(handle, selected_id, &format); + + TC_PRT("ret : %d", ret); + TC_PRT("selected id[%d] - filename[%s], format[%s]\n", selected_id, filename, test_filetype_to_string(format)); + + g_free(filename); + } + + ret = mtp_get_object_handles(handle, (strg_handle > 0 ? strg_handle : 0), MTP_FILETYPE_JPEG, selected_id, &object_list2, &object_count2); + + TC_PRT("Total object_num [%d]", object_count2); + + for (i = 0; i < object_count2; i++) { + TC_PRT("object handle %d", object_list2[i]); + + ret = mtp_objectinfo_get_filename(handle, object_list2[i], &filename); + ret = mtp_objectinfo_get_format(handle, object_list2[i], &format); + + TC_PRT("ret : %d", ret); + TC_PRT("JPEG id[%d] - filename[%s], format[%s]\n", object_list2[i], filename, test_filetype_to_string(format)); + } + + while (true) { + if (!test_get_user_int("==> 2. Input JPEG Object ID (Enter for exit):", &input_object_id2)) { + TC_PRT("input_object_id2 : %d", input_object_id2); + break; + } + + ret = mtp_objectinfo_get_filename(handle, input_object_id2, &filename); + ret = mtp_objectinfo_get_format(handle, input_object_id2, &format); + + TC_PRT("ret : %d", ret); + TC_PRT("selected id[%d] - filename[%s], format[%s]\n", input_object_id2, filename, test_filetype_to_string(format)); + + g_free(filename); + + if (format == MTP_FILETYPE_JPEG) { + snprintf(filepath, 100, "/home/JpegObject_%d.jpg", input_object_id2); + + ret = mtp_get_object(handle, input_object_id2, filepath); + TC_PRT("mtp_get_object ret : %d", ret); + } + } + + END(); + return ret; +} + +int application_test_get_object_handle_using_all(void) +{ + int i; + int ret = 0; + int *file_list; + int file_count; + + BEGIN(); + + ret = mtp_get_object_handles(handle, strg_handle, MTP_FILETYPE_ALL, 0, &file_list, &file_count); + + TC_PRT("ret[%d]: total folder_count[%d]", ret, file_count); + for (i = 0; i < file_count; i++) + TC_PRT("object handle [%d] : %d", file_count, file_list[i]); + + END(); + return ret; +} + +int application_test_get_object_handle_using_all_image(void) +{ + int i; + int *file_list; + int file_count; + int ret = 0; + BEGIN(); + + ret = mtp_get_object_handles(handle, strg_handle, MTP_FILETYPE_ALL_IMAGE, 0, &file_list, &file_count); + + TC_PRT("ret[%d]: total folder_count[%d]", ret, file_count); + for (i = 0; i < file_count; i++) + TC_PRT("object handle [%d] : %d", file_count, file_list[i]); + + END(); + return ret; +} + +void __test_mtp_event_cb(mtp_event_e state, int arg, void *user_data) +{ + TC_PRT("state [%d] : %d", state, arg); +} + +int application_test_event_callback(void) +{ + int ret; + + BEGIN(); + + ret = mtp_set_mtp_event_cb(__test_mtp_event_cb, NULL); + + END(); + + return ret; +} + +int application_test_scenario(void) +{ + int i; + int ret; + int device_handle = 0; + int *storage_list; + int storage_count = 0; + int *image_list; + int image_count = 0; + mtp_device_list* dev_list; + struct timeval start1, start2, start3, start4; + struct timeval end1, end2, end3, end4; + + BEGIN(); + + /* init phase */ + gettimeofday(&start1, NULL); + TC_PRT("init phase start, %ld.%ld", start1.tv_sec, start1.tv_usec); + + ret = mtp_initialize(); + + ret = mtp_get_device_list(&dev_list); + + if (dev_list->device_num == 0) { + TC_PRT("device is not exist!!!"); + END(); + return -1; + } + + ret = mtp_get_device_handle(dev_list->devices[0].bus_location, &device_handle); + ret = mtp_get_storage_ids(device_handle, &storage_list, &storage_count); + + gettimeofday(&end1, NULL); + TC_PRT("init phase end time, %ld.%ld", end1.tv_sec, end1.tv_usec); + + /* scan phase */ + gettimeofday(&start2, NULL); + TC_PRT("scan phase start, %ld.%ld", start2.tv_sec, start2.tv_usec); + + ret = mtp_get_object_handles(device_handle, storage_list[0], MTP_FILETYPE_ALL_IMAGE, + 0, &image_list, &image_count); + + gettimeofday(&end2, NULL); + TC_PRT("scan phase end time, %ld.%ld", end2.tv_sec, end2.tv_usec); + + /* get objectinfo phase */ + gettimeofday(&start3, NULL); + TC_PRT("get objectinfo phase start, %ld.%ld", start3.tv_sec, start3.tv_usec); + + for (i = 0; i < image_count; i++) { + mtp_object_info *object_info; + mtp_objectinfo_get_object_info(device_handle, image_list[i], &object_info); + TC_PRT("filename : %s", object_info->Filename); + g_free(object_info); + } + + gettimeofday(&end3, NULL); + TC_PRT("get objectinfo phase end, %ld.%ld", end3.tv_sec, end3.tv_usec); + + /* get thumbnail phase */ + gettimeofday(&start4, NULL); + TC_PRT("get thumbnail phase start, %ld.%ld", start4.tv_sec, start4.tv_usec); + + for (i = 0; i < image_count; i++) { + char path[256] = {0,}; + + snprintf(path, 256, "/tmp/thumbnail%d.jpg", i); + mtp_get_thumbnail(device_handle, image_list[i], path); + } + gettimeofday(&end4, NULL); + TC_PRT("get thumbnail phase end, %ld.%ld", end4.tv_sec, end4.tv_usec); + + ret = mtp_deinitialize(); + + END(); + + return ret; +} + +tc_table_t tc_table[] = { + /* manager api */ + {"mtp_initialize", 1, manager_test_initialize}, + {"mtp_get_device_list", 2, manager_test_get_device_list}, + {"mtp_get_device_handle", 3, manager_test_get_device_handle}, + {"mtp_get_storage_ids", 4, manager_test_get_storage_ids}, + {"mtp_get_object_handles", 5, manager_test_get_object_handles}, + {"mtp_delete_object", 6, manager_test_delete_object}, + {"mtp_get_object", 7, manager_test_get_object}, + {"mtp_get_thumbnail", 8, manager_test_get_thumbnail}, + {"mtp_deinitialize", 9, manager_test_deinitialize}, + + /* device api */ + {"mtp_deviceinfo_manufacturer_name", 10, deviceinfo_test_get_manufacturername}, + {"mtp_deviceinfo_model_name", 11, deviceinfo_test_get_modelname}, + {"mtp_deviceinfo_serial_number", 12, deviceinfo_test_get_serialnumber}, + {"mtp_deviceinfo_device_version", 13, deviceinfo_test_get_deviceversion}, + + /* storage api */ + {"mtp_storageinfo_get_description", 14, storageinfo_test_get_description}, + {"mtp_storageinfo_get_freespace", 15, storageinfo_test_get_freespace}, + {"mtp_storageinfo_get_maxcapacity", 16, storageinfo_test_get_maxcapacity}, + {"mtp_storageinfo_get_storagetype", 17, storageinfo_test_get_storagetype}, + {"mtp_storageinfo_get_volumeidentifier", 18, storageinfo_test_get_volumeidentifier}, + + /* object api */ + {"mtp_objectinfo_get_association_desc", 19, objectinfo_test_get_association_desc}, + {"mtp_objectinfo_get_association_type", 20, objectinfo_test_get_association_type}, + {"mtp_objectinfo_get_size", 21, objectinfo_test_get_size}, + {"mtp_objectinfo_get_data_created", 22, objectinfo_test_get_data_created}, + {"mtp_objectinfo_get_data_modified", 23, objectinfo_test_get_data_modified}, + {"mtp_objectinfo_get_format", 24, objectinfo_test_get_format}, + {"mtp_objectinfo_get_image_pix_depth", 25, objectinfo_test_get_image_pix_depth}, + {"mtp_objectinfo_get_image_pix_width", 26, objectinfo_test_get_image_pix_width}, + {"mtp_objectinfo_get_image_pix_height", 27, objectinfo_test_get_image_pix_height}, + {"mtp_objectinfo_get_thumbnail_size", 28, objectinfo_test_get_thumbnail_size}, + {"mtp_objectinfo_get_thumbnail_format", 29, objectinfo_test_get_thumbnail_format}, + {"mtp_objectinfo_get_thumbnail_pix_height", 30, objectinfo_test_get_thumbnail_pix_height}, + {"mtp_objectinfo_get_thumbnail_pix_width", 31, objectinfo_test_get_thumbnail_pix_width}, + {"mtp_objectinfo_get_filename", 32, objectinfo_test_get_filename}, + {"mtp_objectinfo_get_keywords", 33, objectinfo_test_get_keywords}, + + /* application test */ + {"get Jpeg image from /DCIM folder", 34, application_test_get_image_from_DCIM}, + {"get object handle using ALL format", 35, application_test_get_object_handle_using_all}, + {"get object handle using ALL Image format", 36, application_test_get_object_handle_using_all_image}, + {"test callback function", 37, application_test_event_callback}, + {"application_test_scenario", 38, application_test_scenario}, + {"get object and get thumbnail test", TEST_CASE_MAX, NULL}, + + /*-----------*/ + {"Finish", 0x0000, NULL}, + {NULL, 0x00ff, NULL}, +}; + +static void tc_usage_print(void) +{ + int i = 0; + + while (tc_table[i].tc_name) { + if (tc_table[i].tc_code != 0x00ff) + printf("Key [%2d] : usage %s\n", tc_table[i].tc_code, tc_table[i].tc_name); + else + printf("Key [%2d] : usage %s\n\n", 0x00ff, tc_table[i].tc_name); + + i++; + } +} + +static int test_input_callback(void *data) +{ + long test_id = (long)data; + int ret = MTP_ERROR_NONE; + + if ((test_id >= 1) && (test_id <= TEST_CASE_MAX)) { + TC_PRT("test_input_callback test_id : %ld", test_id); + + if (tc_table[test_id-1].tc_func != NULL) { + ret = tc_table[test_id-1].tc_func(); + + if (ret != MTP_ERROR_NONE) + TC_PRT(">>>>> Test Error Returned !!! : %d", ret); + } + } + + return 0; +} + +static int test_mtp_terminate(void) +{ + int ret = 0; + + TC_PRT("Finished"); + + manager_test_deinitialize(); + g_main_loop_quit(main_loop); + + return ret; +} + +static gboolean key_event_cb(GIOChannel *chan, GIOCondition cond, gpointer data) +{ + char buf[BUFFER_LEN] = {0,}; + long test_id; + int rv = 0; + + memset(buf, 0, sizeof(buf)); + printf("Event received from stdin\n"); + + rv = read(0, buf, 100); + + if (rv < 0 || buf[0] == '0') { + test_mtp_terminate(); + exit(1); + } + + if (*buf == '\n' || *buf == '\r') + tc_usage_print(); + + test_id = atoi(buf); + + test_input_callback((void *)test_id); + + return TRUE; +} + + +int main(int argc, char ** argv) +{ + GIOChannel *key_io; + + main_loop = g_main_loop_new(NULL, FALSE); + key_io = g_io_channel_unix_new(0); + + printf("Test Thread created...\n"); + + g_io_add_watch(key_io, (G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL), key_event_cb, NULL); + g_main_loop_run(main_loop); + + g_io_channel_unref(key_io); + g_main_loop_unref(main_loop); + + return 0; +} -- 2.7.4