From 3a6e9c07de85bdb8bfd9b0c58b770a11ff87e920 Mon Sep 17 00:00:00 2001 From: Piotr Kosko Date: Thu, 7 Jan 2016 08:31:33 +0100 Subject: [PATCH] [Systeminfo] Added handling Storage for TV profile in Systeminfo [Feature] Added two implementations of signal handling. Active one could be switched by define. 1. was based on implementation from tizen_2.4_tv_product_migration branch 2. was based on web wiki: https://wiki.tizen.org/wiki/System:Deviced#Usb_host specification On binary: 20160107.4, implementation based on Usb_host interface is correct and was tested and works correctly. Implementation 1 (based on tizen_2.4_tv_product_migration) seems to work in case of gathering storages also. [Verification] On TV target 20160107.3 tct passrate: Archive 100% Content 100% Download 100% Systeminfo 100% Filesystem 100%. On TM1 device tct passrate: Archive 100% Content 100% Filesystem 100% Notification 100% Systeminfo 100% Systemsetting 96.97% (1 fail - SystemSettingManager_setProperty_errorCallback_invoked - binary issue) Change-Id: I645119ecf949c4290f5307e74a5dcc0ee57e4d6f Signed-off-by: Piotr Kosko --- src/common/common.gypi | 2 +- .../filesystem/filesystem_provider_deviced.cc | 94 ++++++++++++++++--- .../filesystem/filesystem_provider_deviced.h | 2 + .../systeminfo_properties_manager.cc | 44 +++++++++ 4 files changed, 128 insertions(+), 14 deletions(-) diff --git a/src/common/common.gypi b/src/common/common.gypi index 0bf14e16..0e15003a 100644 --- a/src/common/common.gypi +++ b/src/common/common.gypi @@ -37,7 +37,7 @@ 'sources/': [['exclude', '_tizen\\.cc$|tizen/']], 'includes/': [['exclude', '_tizen\\.gypi$|tizen/']], }], - ['extension_host_os == "tv"', { 'defines': ['TIZEN_TV'] } ], + ['extension_host_os == "tv"', { 'defines': ['TIZEN_TV', 'USBHOST'] } ], ['extension_host_os == "wearable"', { 'defines': ['TIZEN_WEARABLE'] } ], ['extension_host_os == "mobile"', { 'defines': ['TIZEN_MOBILE'] } ], ['extension_host_os == "ivi"', { 'defines': ['TIZEN_IVI'] } ], diff --git a/src/common/filesystem/filesystem_provider_deviced.cc b/src/common/filesystem/filesystem_provider_deviced.cc index ac08abc1..e4013764 100644 --- a/src/common/filesystem/filesystem_provider_deviced.cc +++ b/src/common/filesystem/filesystem_provider_deviced.cc @@ -28,8 +28,14 @@ #include "common/logger.h" namespace { +static const char* kDeviceDName = "org.tizen.system.deviced"; +#ifdef USBHOST +static const char* kIface = "org.tizen.system.deviced.Usbhost"; +static const char* kPath = "/Org/Tizen/System/DeviceD/Usbhost"; +#else static const char* kIface = "org.tizen.system.deviced.BlockManager"; static const char* kPath = "/Org/Tizen/System/DeviceD/Block/Manager"; +#endif } // namespace namespace common { @@ -61,6 +67,29 @@ struct DeviceListElem { bool primary; }; +struct UsbListElem { + UsbListElem() + : usb_devpath(nullptr), + usb_class(0), + usb_subclass(0), + usb_protocol(0), + usb_vendor_id(0), + usb_product_id(0), + usb_manufacturer(nullptr), + usb_product_name(nullptr), + usb_serial(nullptr) {} + + char* usb_devpath; + int usb_class; + int usb_subclass; + int usb_protocol; + int usb_vendor_id; + int usb_product_id; + char* usb_manufacturer; + char* usb_product_name; + char* usb_serial; +}; + FilesystemProviderDeviced::~FilesystemProviderDeviced() { LoggerD("Entered"); UnregisterDeviceChangeState(); @@ -85,9 +114,8 @@ FilesystemProviderDeviced::FilesystemProviderDeviced() : LoggerE("Dbus handle is null"); } else { LoggerE("Dbus connection set"); - const gchar* unique_name = g_dbus_connection_get_unique_name(dbus_); proxy_ = g_dbus_proxy_new_sync(dbus_, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, - nullptr, unique_name, kPath, kIface, nullptr, + nullptr, kDeviceDName, kPath, kIface, nullptr, &error); if (!proxy_ || error) { LoggerE("Could not get dbus proxy. %s", error->message); @@ -183,6 +211,22 @@ std::shared_ptr FilesystemProviderDeviced::GetStorage(const DeviceListE elem.syspath, GetNameFromPath(elem.devnode))); } +std::shared_ptr FilesystemProviderDeviced::GetStorageUsb(const UsbListElem& elem) { + LoggerD("Entered"); + SLoggerD("usb_devpath %s", elem.usb_devpath); + SLoggerD("usb_class %d", elem.usb_class); + SLoggerD("usb_subclass %d", elem.usb_subclass); + SLoggerD("usb_protocol %d", elem.usb_protocol); + SLoggerD("usb_vendor_id %d", elem.usb_vendor_id); + SLoggerD("usb_product_id %d", elem.usb_product_id); + SLoggerD("usb_manufacturer %s", elem.usb_manufacturer); + SLoggerD("usb_product_name %s", elem.usb_product_name); + SLoggerD("usb_serial %s", elem.usb_serial); + return std::make_shared(Storage(elem.usb_product_id, StorageType::kExternal, + StorageState::kMounted, // TODO: check if found storage is always mounted + elem.usb_devpath, GetNameFromPath(elem.usb_devpath))); +} + std::string FilesystemProviderDeviced::GetNameFromPath( const char* const char_path) { LoggerD("Entered"); @@ -215,9 +259,15 @@ Storages FilesystemProviderDeviced::GetStorages() { } GError* error = nullptr; +#ifdef USBHOST + GVariant* variant = g_dbus_proxy_call_sync( + proxy_, "GetDeviceList", g_variant_new("(i)", "0xffffffff"), + G_DBUS_CALL_FLAGS_NONE, -1, nullptr, &error); +#else GVariant* variant = g_dbus_proxy_call_sync( proxy_, "GetDeviceList", g_variant_new("(s)", "all"), G_DBUS_CALL_FLAGS_NONE, -1, nullptr, &error); +#endif if (!variant || error) { LoggerE("Failed to call GetDeviceList method - %s", error->message); return Storages(); @@ -228,18 +278,36 @@ Storages FilesystemProviderDeviced::GetStorages() { Storages FilesystemProviderDeviced::GetStoragesFromGVariant(GVariant* variant) { LoggerD("Entered"); + SLoggerD("Imput variant looks like:\ng_variant_print(variant): %s", g_variant_print (variant, TRUE)); Storages storages; - GVariantIter iter; - GVariant* tuple = nullptr; - g_variant_iter_init(&iter, variant); - while ((tuple = g_variant_iter_next_value(&iter))) { - DeviceListElem elem; - g_variant_get(tuple, "(issssssisib)", &elem.block_type, &elem.devnode, - &elem.syspath, &elem.fs_usage, &elem.fs_type, - &elem.fs_version, &elem.fs_uuid_enc, &elem.readonly, - &elem.mount_point, &elem.state, &elem.primary); - storages.push_back(GetStorage(elem)); - g_variant_unref(tuple); + GVariantIter iter_variant; + GVariant* array = nullptr; + g_variant_iter_init(&iter_variant, variant); + while ((array = g_variant_iter_next_value(&iter_variant))) { + GVariantIter iter_array; + g_variant_iter_init (&iter_array, array); + GVariant* array_elem = nullptr; + + while ((array_elem = g_variant_iter_next_value (&iter_array))) { + SLoggerD("Adding storage: g_variant_print(array_elem): %s", g_variant_print (array_elem, TRUE)); +#ifdef USBHOST + UsbListElem elem; + g_variant_get(array_elem, "(siiiiisss)", &elem.usb_devpath, &elem.usb_class, + &elem.usb_subclass, &elem.usb_protocol, &elem.usb_vendor_id, + &elem.usb_product_id, &elem.usb_manufacturer, &elem.usb_product_name, + &elem.usb_serial); + storages.push_back(GetStorageUsb(elem)); +#else + DeviceListElem elem; + g_variant_get(array_elem, "(issssssisib)", &elem.block_type, &elem.devnode, + &elem.syspath, &elem.fs_usage, &elem.fs_type, + &elem.fs_version, &elem.fs_uuid_enc, &elem.readonly, + &elem.mount_point, &elem.state, &elem.primary); + storages.push_back(GetStorage(elem)); +#endif + g_variant_unref(array_elem); + } + g_variant_unref(array); } return storages; } diff --git a/src/common/filesystem/filesystem_provider_deviced.h b/src/common/filesystem/filesystem_provider_deviced.h index c3094454..bae0ea5b 100644 --- a/src/common/filesystem/filesystem_provider_deviced.h +++ b/src/common/filesystem/filesystem_provider_deviced.h @@ -33,6 +33,7 @@ namespace common { struct DeviceListElem; +struct UsbListElem; class FilesystemProviderDeviced : public IFilesystemProvider { public: @@ -59,6 +60,7 @@ class FilesystemProviderDeviced : public IFilesystemProvider { static std::string GetNameFromPath(const char* const char_path); static int GetIdFromUUID(const char* const char_uuid); static std::shared_ptr GetStorage(const DeviceListElem& elem); + static std::shared_ptr GetStorageUsb(const UsbListElem& elem); static Storages GetStoragesFromGVariant(GVariant* variant); GDBusConnection* dbus_; GDBusProxy* proxy_; diff --git a/src/systeminfo/systeminfo_properties_manager.cc b/src/systeminfo/systeminfo_properties_manager.cc index 79c4c7ff..1c342458 100644 --- a/src/systeminfo/systeminfo_properties_manager.cc +++ b/src/systeminfo/systeminfo_properties_manager.cc @@ -31,6 +31,7 @@ #include "systeminfo/systeminfo_device_capability.h" #include "common/scope_exit.h" #include "systeminfo/systeminfo-utils.h" +#include "common/filesystem/filesystem_provider.h" namespace extension { namespace systeminfo { @@ -60,6 +61,7 @@ const std::string kStorageSdcardPath = std::string(tzplatform_getenv(TZ_SYS_STOR const std::string kPropertyIdStorage = "STORAGE"; const std::string kTypeUnknown = "UNKNOWN"; const std::string kTypeInternal = "INTERNAL"; +const std::string kTypeUsbDevice = "USB_DEVICE"; const std::string kTypeUsbHost = "USB_HOST"; const std::string kTypeMmc = "MMC"; //Network @@ -1174,6 +1176,47 @@ static void CreateStorageInfo(const std::string& type, struct statfs& fs, picojs out->insert(std::make_pair("isRemovable", picojson::value(isRemovable))); } +#ifdef TIZEN_TV +PlatformResult SysteminfoPropertiesManager::ReportStorage(picojson::object* out) { + LoggerD("Enter"); + + picojson::value result = picojson::value(picojson::array()); + picojson::array& array = result.get(); + + struct statfs fs; + + // handling internal storage + array.push_back(picojson::value(picojson::object())); + picojson::object& internal_obj = array.back().get(); + if (statfs(kStorageInternalPath.c_str(), &fs) < 0) { + return LogAndCreateResult( + ErrorCode::UNKNOWN_ERR, "There are no storage units detected"); + } + CreateStorageInfo(kTypeInternal, fs, &internal_obj); + manager_.SetAvailableCapacityInternal(fs.f_bavail); + + // handling external storages + common::FilesystemProvider& provider(common::FilesystemProvider::Create()); + auto storages = provider.GetStorages(); + LoggerD("Storages found %d", storages.size()); + for (auto storage : storages) { + if (storage->state() == common::StorageState::kMounted) { + if (statfs(storage->path().c_str(), &fs) < 0) { + LoggerE("Storage unit %s not detected", storage->name().c_str()); + return PlatformResult(ErrorCode::UNKNOWN_ERR, "Storage unit not detected"); + } + array.push_back(picojson::value(picojson::object())); + internal_obj = array.back().get(); + CreateStorageInfo(kTypeUsbDevice, fs, &internal_obj); + // TODO some tracking of available capacity of usb storages should be applied + } + } + + out->insert(std::make_pair("storages", picojson::value(result))); + return PlatformResult(ErrorCode::NO_ERROR); +} +#else + PlatformResult SysteminfoPropertiesManager::ReportStorage(picojson::object* out) { LoggerD("Entered"); int sdcardState = 0; @@ -1209,6 +1252,7 @@ PlatformResult SysteminfoPropertiesManager::ReportStorage(picojson::object* out) out->insert(std::make_pair("storages", picojson::value(result))); return PlatformResult(ErrorCode::NO_ERROR); } +#endif PlatformResult SysteminfoPropertiesManager::ReportCameraFlash(picojson::object* out, unsigned long index) { -- 2.34.1