#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* kBus = "org.tizen.system.deviced";
+static const char* kBlockIface = "org.tizen.system.deviced.Block";
+static const char* kBlackManagerIface = "org.tizen.system.deviced.BlockManager";
static const char* kPath = "/Org/Tizen/System/DeviceD/Block/Manager";
-#endif
+static const char* kDeviceChangedMethod = "DeviceChanged";
+static const char* kGetDeviceListMethod = "GetDeviceList";
} // namespace
namespace common {
LoggerE("Dbus handle is null");
} else {
LoggerE("Dbus connection set");
- proxy_ = g_dbus_proxy_new_sync(dbus_, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
- nullptr, kDeviceDName, kPath, kIface, nullptr,
- &error);
- if (!proxy_ || error) {
- LoggerE("Could not get dbus proxy. %s", error->message);
- } else {
- is_initialized_ = true;
- }
+ is_initialized_ = true;
}
}
}
if (device_changed_callback_ == nullptr) {
LoggerD("Registering dbus signal subscription");
block_signal_subscribe_id_ = g_dbus_connection_signal_subscribe(
- dbus_, nullptr, "org.tizen.system.deviced.Block", "DeviceChanged",
+ dbus_, nullptr, kBlockIface, kDeviceChangedMethod,
nullptr, nullptr, G_DBUS_SIGNAL_FLAGS_NONE, BlockSignalProxy, this,
nullptr);
}
std::shared_ptr<Storage> FilesystemProviderDeviced::GetStorage(const DeviceListElem& elem) {
LoggerD("Entered");
- return std::make_shared<Storage>(Storage(GetIdFromUUID(elem.fs_uuid_enc), StorageType::kExternal,
+ return std::make_shared<Storage>(GetIdFromUUID(elem.fs_uuid_enc),
+ (elem.block_type ? StorageType::kMmc : StorageType::kUsbDevice),
(elem.state ? StorageState::kMounted : StorageState::kUnmounted),
- elem.syspath, GetNameFromPath(elem.devnode)));
-}
-
-std::shared_ptr<Storage> 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>(Storage(elem.usb_product_id, StorageType::kExternal,
- StorageState::kMounted, // TODO: check if found storage is always mounted
- elem.usb_devpath, GetNameFromPath(elem.usb_devpath)));
+ elem.mount_point,
+ GetNameFromPath(elem.devnode));
}
std::string FilesystemProviderDeviced::GetNameFromPath(
std::string uuid = char_uuid;
size_t hyphen = uuid.find("-");
std::string clear_uuid = uuid.substr(0, hyphen) + uuid.substr(hyphen + 1);
- return static_cast<int>(std::stoul(clear_uuid, 0, 16));
+ return static_cast<unsigned int>(std::stoul(clear_uuid, nullptr, 16));
}
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
+ GVariant* variant = g_dbus_connection_call_sync(dbus_,
+ kBus,
+ kPath,
+ kBlackManagerIface,
+ kGetDeviceListMethod,
+ g_variant_new("(s)", "all"),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
if (!variant || error) {
LoggerE("Failed to call GetDeviceList method - %s", error->message);
return Storages();
}
- LoggerD("GetDeviceList called");
return GetStoragesFromGVariant(variant);
}
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_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);
+ GVariantIter *iter;
+
+ g_variant_get(variant, "(a(issssssisib))", &iter);
+ DeviceListElem elem;
+ while (g_variant_iter_loop(iter, "(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)) {
+ SLoggerD("##### DEVICE INFO #####");
+ SLoggerD("# block_type : (%d)", elem.block_type);
+ SLoggerD("# devnode : (%s)", elem.devnode);
+ SLoggerD("# syspath : (%s)", elem.syspath);
+ SLoggerD("# fs_usage : (%s)", elem.fs_usage);
+ SLoggerD("# fs_type : (%s)", elem.fs_type);
+ SLoggerD("# fs_version : (%s)", elem.fs_version);
+ SLoggerD("# fs_uuid_enc: (%s)", elem.fs_uuid_enc);
+ SLoggerD("# readonly : (%d)", elem.readonly);
+ SLoggerD("# mount_point: (%s)", elem.mount_point);
+ SLoggerD("# state : (%d)", elem.state);
+ SLoggerD("# primary : (%s)", elem.primary ? "true" : "false");
+ storages.push_back(GetStorage(elem));
}
+ g_variant_iter_free(iter);
+ g_variant_unref(variant);
return storages;
}
const std::string kVirtualRootMedia = "internal0";
const std::map<storage_directory_e, const std::string*> kStorageDirectories = {
- { STORAGE_DIRECTORY_CAMERA, &kVirtualRootCamera }, {
- STORAGE_DIRECTORY_DOCUMENTS, &kVirtualRootDocuments }, {
- STORAGE_DIRECTORY_DOWNLOADS, &kVirtualRootDownloads }, {
- STORAGE_DIRECTORY_IMAGES, &kVirtualRootImages }, {
- STORAGE_DIRECTORY_MUSIC, &kVirtualRootMusic }, {
- STORAGE_DIRECTORY_SYSTEM_RINGTONES, &kVirtualRootRingtones }, {
- STORAGE_DIRECTORY_VIDEOS, &kVirtualRootVideos } };
+ { STORAGE_DIRECTORY_CAMERA, &kVirtualRootCamera },
+ { STORAGE_DIRECTORY_DOCUMENTS, &kVirtualRootDocuments },
+ { STORAGE_DIRECTORY_DOWNLOADS, &kVirtualRootDownloads },
+ { STORAGE_DIRECTORY_IMAGES, &kVirtualRootImages },
+ { STORAGE_DIRECTORY_MUSIC, &kVirtualRootMusic },
+ { STORAGE_DIRECTORY_SYSTEM_RINGTONES, &kVirtualRootRingtones },
+ { STORAGE_DIRECTORY_VIDEOS, &kVirtualRootVideos } };
const std::string kFileUriPrefix = "file://";
StorageType type_ =
type == STORAGE_TYPE_INTERNAL ?
- StorageType::kInternal : StorageType::kExternal;
+ StorageType::kInternal : StorageType::kUnknown;
provider->GetStorages().push_back(
std::make_shared<Storage>(storage_id, type_, TranslateCoreStorageState(state), path));
out->insert(std::make_pair("isRemovable", picojson::value(isRemovable)));
}
-#ifdef TIZEN_TV
+static std::string FromStorageTypeToStringType(common::StorageType type) {
+ switch(type) {
+ case common::StorageType::kUsbDevice:
+ return kTypeUsbDevice;
+ case common::StorageType::kUsbHost:
+ return kTypeUsbHost;
+ case common::StorageType::kMmc:
+ return kTypeMmc;
+ default:
+ return kTypeUnknown;
+ }
+}
+
PlatformResult SysteminfoPropertiesManager::ReportStorage(picojson::object* out) {
- LoggerD("Enter");
+ LoggerD("Entered");
+ int sdcardState = 0;
+ struct statfs fs;
picojson::value result = picojson::value(picojson::array());
picojson::array& array = result.get<picojson::array>();
- struct statfs fs;
-
// handling internal storage
array.push_back(picojson::value(picojson::object()));
picojson::object& internal_obj = array.back().get<picojson::object>();
+
if (statfs(kStorageInternalPath.c_str(), &fs) < 0) {
return LogAndCreateResult(
ErrorCode::UNKNOWN_ERR, "There are no storage units detected");
manager_.SetAvailableCapacityInternal(fs.f_bavail);
// handling external storages
+#ifdef TIZEN_TV
common::FilesystemProvider& provider(common::FilesystemProvider::Create());
auto storages = provider.GetStorages();
LoggerD("Storages found %d", storages.size());
return PlatformResult(ErrorCode::UNKNOWN_ERR, "Storage unit not detected");
}
array.push_back(picojson::value(picojson::object()));
-
internal_obj = array.back().get<picojson::object>();
- CreateStorageInfo(kTypeUsbDevice, fs, &internal_obj);
+
picojson::object& external_obj = array.back().get<picojson::object>();
+ CreateStorageInfo(FromStorageTypeToStringType(storage->type()), fs, &external_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;
- struct statfs fs;
-
- picojson::value result = picojson::value(picojson::array());
-
- picojson::array& array = result.get<picojson::array>();
- array.push_back(picojson::value(picojson::object()));
- picojson::object& internal_obj = array.back().get<picojson::object>();
-
-
- 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);
-
if (0 == vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &sdcardState)) {
if (VCONFKEY_SYSMAN_MMC_MOUNTED == sdcardState){
if (statfs(kStorageSdcardPath.c_str(), &fs) < 0) {
manager_.SetAvailableCapacityMmc(fs.f_bavail);
}
}
-
+#endif
out->insert(std::make_pair("storages", picojson::value(result)));
return PlatformResult(ErrorCode::NO_ERROR);
}
-#endif
+
PlatformResult SysteminfoPropertiesManager::ReportCameraFlash(picojson::object* out,
unsigned long index) {
projects / platform / core / api / webapi-plugins.git / commitdiff