namespace {
// The privileges that required in Download API
const std::string kPrivilegeDownload = "http://tizen.org/privilege/download";
+const std::string kDownloadManagerListenerId = "DownloadManagerListener";
} // namespace
using std::placeholders::_2;
#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&DownloadInstance::x, this, _1, _2));
REGISTER_SYNC("DownloadManager_pause", DownloadManagerPause);
- REGISTER_SYNC("DownloadManager_getDownloadRequest", DownloadManagerGetdownloadrequest);
- REGISTER_SYNC("DownloadManager_setListener", DownloadManagerSetlistener);
REGISTER_SYNC("DownloadManager_getMIMEType", DownloadManagerGetmimetype);
REGISTER_SYNC("DownloadManager_start", DownloadManagerStart);
REGISTER_SYNC("DownloadManager_cancel", DownloadManagerCancel);
DownloadInstance::~DownloadInstance() {
ScopeLogger();
int ret;
+
+ std::lock_guard<std::mutex> lock(instances_mutex_);
+
for (DownloadCallbackMap::iterator it = download_callbacks.begin();
it != download_callbacks.end(); ++it) {
- DownloadInfoPtr diPtr = it->second->instance->diMap[it->second->callbackId];
- SLoggerD("~DownloadInstance() for callbackID %d Called", it->second->callbackId);
+ DownloadInfoPtr di_ptr = it->second->instance->di_map[it->second->download_id];
+ SLoggerD("~DownloadInstance() for callbackID %d Called", it->second->download_id);
- if (diPtr) {
- ret = download_unset_state_changed_cb(diPtr->download_id);
+ if (di_ptr) {
+ ret = download_unset_state_changed_cb(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE)
LoggerE("download_unset_state_changed_cb() is failed. (%s)", get_error_message(ret));
- ret = download_unset_progress_cb(diPtr->download_id);
+ ret = download_unset_progress_cb(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE)
LoggerE("download_unset_progress_cb() is failed. (%s)", get_error_message(ret));
- ret = download_cancel(diPtr->download_id);
+ ret = download_cancel(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE)
LoggerE("download_cancel() is failed. (%s)", get_error_message(ret));
- ret = download_destroy(diPtr->download_id);
+ ret = download_destroy(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE)
LoggerE("download_destroy() is failed. (%s)", get_error_message(ret));
} else {
- LoggerD("diPtr is nullptr");
+ LoggerD("di_ptr is nullptr");
}
delete (it->second);
}
- std::lock_guard<std::mutex> lock(instances_mutex_);
for (auto it = instances_.begin(); it != instances_.end(); it++) {
if (*it == this) {
instances_.erase(it);
void DownloadInstance::OnStateChanged(int download_id, download_state_e state, void* user_data) {
ScopeLogger();
- CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
+ CallbackPtr down_cb_ptr = static_cast<CallbackPtr>(user_data);
// Prevent to call finished, cancelled or failed function more than once
- if (DOWNLOAD_STATE_COMPLETED == downCbPtr->state || DOWNLOAD_STATE_CANCELED == downCbPtr->state ||
- DOWNLOAD_STATE_FAILED == downCbPtr->state) {
- LoggerD("Already finished job, not calling callback for %d state", downCbPtr->state);
+ if (DOWNLOAD_STATE_COMPLETED == down_cb_ptr->state ||
+ DOWNLOAD_STATE_CANCELED == down_cb_ptr->state ||
+ DOWNLOAD_STATE_FAILED == down_cb_ptr->state) {
+ LoggerD("Already finished job, not calling callback for %d state", down_cb_ptr->state);
return;
}
- downCbPtr->state = state;
- downCbPtr->downloadId = download_id;
+ down_cb_ptr->state = state;
+ down_cb_ptr->native_download_id = download_id;
- SLoggerD("State for callbackId %d changed to %d", downCbPtr->callbackId, static_cast<int>(state));
+ SLoggerD("State for callbackId %d changed to %d", down_cb_ptr->download_id,
+ static_cast<int>(state));
switch (state) {
case DOWNLOAD_STATE_NONE:
OnStart(download_id, user_data);
break;
case DOWNLOAD_STATE_PAUSED:
- g_idle_add(OnPaused, downCbPtr);
+ g_idle_add(OnPaused, down_cb_ptr);
break;
case DOWNLOAD_STATE_COMPLETED:
- g_idle_add(OnFinished, downCbPtr);
+ g_idle_add(OnFinished, down_cb_ptr);
break;
case DOWNLOAD_STATE_CANCELED:
- g_idle_add(OnCanceled, downCbPtr);
+ g_idle_add(OnCanceled, down_cb_ptr);
break;
case DOWNLOAD_STATE_FAILED:
- g_idle_add(OnFailed, downCbPtr);
+ g_idle_add(OnFailed, down_cb_ptr);
break;
default:
LoggerD("Unexpected download state: %d", state);
gboolean DownloadInstance::OnProgressChanged(void* user_data) {
ScopeLogger();
- CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
+ CallbackPtr down_cb_ptr = static_cast<CallbackPtr>(user_data);
std::lock_guard<std::mutex> lock(instances_mutex_);
- if (!CheckInstance(downCbPtr->instance)) {
+ if (!CheckInstance(down_cb_ptr->instance)) {
return FALSE;
}
- DownloadInfoPtr diPtr = downCbPtr->instance->diMap[downCbPtr->callbackId];
- if (!diPtr) {
- LoggerW("Download handle does not exist for callback id %d", downCbPtr->callbackId);
+ DownloadInfoPtr di_ptr = down_cb_ptr->instance->di_map[down_cb_ptr->download_id];
+ if (!di_ptr) {
+ LoggerW("Download handle does not exist for callback id %d", down_cb_ptr->download_id);
return FALSE;
}
picojson::value::object out;
out["status"] = picojson::value("progress");
- out["callbackId"] = picojson::value(static_cast<double>(downCbPtr->callbackId));
- out["receivedSize"] = picojson::value(static_cast<double>(downCbPtr->received));
- out["totalSize"] = picojson::value(static_cast<double>(diPtr->file_size));
+ out["downloadId"] = picojson::value(static_cast<double>(down_cb_ptr->download_id));
+ out["receivedSize"] = picojson::value(static_cast<double>(down_cb_ptr->received));
+ out["totalSize"] = picojson::value(static_cast<double>(di_ptr->file_size));
+ out["listenerId"] = picojson::value(kDownloadManagerListenerId);
- LoggerD("OnProgressChanged for callbackId %d Called: Received: %ld", downCbPtr->callbackId,
- downCbPtr->received);
+ LoggerD("OnProgressChanged for callbackId %d Called: Received: %llu", down_cb_ptr->download_id,
+ down_cb_ptr->received);
picojson::value v = picojson::value(out);
- Instance::PostMessage(downCbPtr->instance, v.serialize().c_str());
+ Instance::PostMessage(down_cb_ptr->instance, v.serialize().c_str());
return FALSE;
}
ScopeLogger();
unsigned long long totalSize;
- CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
+ CallbackPtr down_cb_ptr = static_cast<CallbackPtr>(user_data);
std::lock_guard<std::mutex> lock(instances_mutex_);
- if (!CheckInstance(downCbPtr->instance)) {
+ if (!CheckInstance(down_cb_ptr->instance)) {
return;
}
- SLoggerD("OnStart for callbackId %d Called", downCbPtr->callbackId);
+ SLoggerD("OnStart for callbackId %d Called", down_cb_ptr->download_id);
- DownloadInfoPtr diPtr = downCbPtr->instance->diMap[downCbPtr->callbackId];
- if (!diPtr) {
- LoggerW("Download handle does not exist for callback id %d", downCbPtr->callbackId);
+ DownloadInfoPtr di_ptr = down_cb_ptr->instance->di_map[down_cb_ptr->download_id];
+ if (!di_ptr) {
+ LoggerW("Download handle does not exist for callback id %d", down_cb_ptr->download_id);
return;
}
download_get_content_size(download_id, &totalSize);
- diPtr->file_size = totalSize;
+ di_ptr->file_size = totalSize;
}
gboolean DownloadInstance::OnFinished(void* user_data) {
ScopeLogger();
char* fullPath = NULL;
- CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
+ CallbackPtr down_cb_ptr = static_cast<CallbackPtr>(user_data);
std::lock_guard<std::mutex> lock(instances_mutex_);
- if (!CheckInstance(downCbPtr->instance)) {
+ if (!CheckInstance(down_cb_ptr->instance)) {
return FALSE;
}
- int callback_id = downCbPtr->callbackId;
- DownloadInfoPtr diPtr = downCbPtr->instance->diMap[callback_id];
- if (!diPtr) {
- LoggerW("Download handle does not exist for callback id %d", downCbPtr->callbackId);
+ int download_id = down_cb_ptr->download_id;
+ DownloadInfoPtr di_ptr = down_cb_ptr->instance->di_map[download_id];
+ if (!di_ptr) {
+ LoggerW("Download handle does not exist for callback id %d", down_cb_ptr->download_id);
return FALSE;
}
- LoggerD("OnFinished for callbackID %d Called", callback_id);
+ LoggerD("OnFinished for callbackID %d Called", download_id);
picojson::value::object out;
- int ret = download_get_downloaded_file_path(downCbPtr->downloadId, &fullPath);
+ int ret = download_get_downloaded_file_path(down_cb_ptr->native_download_id, &fullPath);
if (ret != DOWNLOAD_ERROR_NONE) {
LogAndReportError(convertError(ret), &out, ("download_get_downloaded_file_path error: %d (%s)",
ret, get_error_message(ret)));
} else {
- ret = download_unset_state_changed_cb(diPtr->download_id);
+ ret = download_unset_state_changed_cb(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE) {
LoggerW("%s", get_error_message(ret));
}
- ret = download_unset_progress_cb(diPtr->download_id);
+ ret = download_unset_progress_cb(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE) {
LoggerW("%s", get_error_message(ret));
}
- ret = download_destroy(diPtr->download_id);
+ ret = download_destroy(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE) {
LoggerW("%s", get_error_message(ret));
}
out["status"] = picojson::value("completed");
}
- out["callbackId"] = picojson::value(static_cast<double>(callback_id));
+ out["downloadId"] = picojson::value(static_cast<double>(download_id));
out["fullPath"] = picojson::value(common::FilesystemProvider::Create().GetVirtualPath(fullPath));
+ out["listenerId"] = picojson::value(kDownloadManagerListenerId);
- Instance::PostMessage(downCbPtr->instance, picojson::value(out).serialize().c_str());
- // downCbPtr is freed in destructor, it prevent from crash if OnFinished state
+ Instance::PostMessage(down_cb_ptr->instance, picojson::value(out).serialize().c_str());
+ // down_cb_ptr is freed in destructor, it prevent from crash if OnFinished state
// was called after OnCanceled or OnFailed
free(fullPath);
gboolean DownloadInstance::OnPaused(void* user_data) {
ScopeLogger();
- CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
+ CallbackPtr down_cb_ptr = static_cast<CallbackPtr>(user_data);
std::lock_guard<std::mutex> lock(instances_mutex_);
- if (!CheckInstance(downCbPtr->instance)) {
+ if (!CheckInstance(down_cb_ptr->instance)) {
return FALSE;
}
- int callback_id = downCbPtr->callbackId;
- DownloadInfoPtr diPtr = downCbPtr->instance->diMap[callback_id];
- if (!diPtr) {
- LoggerW("Download handle does not exist for callback id %d", downCbPtr->callbackId);
+ int download_id = down_cb_ptr->download_id;
+ DownloadInfoPtr di_ptr = down_cb_ptr->instance->di_map[download_id];
+ if (!di_ptr) {
+ LoggerW("Download handle does not exist for callback id %d", down_cb_ptr->download_id);
return FALSE;
}
- LoggerD("OnPaused for callbackID %d Called", callback_id);
+ LoggerD("OnPaused for callbackID %d Called", download_id);
picojson::value::object out;
out["status"] = picojson::value("paused");
- out["callbackId"] = picojson::value(static_cast<double>(callback_id));
+ out["downloadId"] = picojson::value(static_cast<double>(download_id));
+ out["listenerId"] = picojson::value(kDownloadManagerListenerId);
- Instance::PostMessage(downCbPtr->instance, picojson::value(out).serialize().c_str());
+ Instance::PostMessage(down_cb_ptr->instance, picojson::value(out).serialize().c_str());
return FALSE;
}
gboolean DownloadInstance::OnCanceled(void* user_data) {
ScopeLogger();
- CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
+ CallbackPtr down_cb_ptr = static_cast<CallbackPtr>(user_data);
std::lock_guard<std::mutex> lock(instances_mutex_);
- if (!CheckInstance(downCbPtr->instance)) {
+ if (!CheckInstance(down_cb_ptr->instance)) {
return FALSE;
}
- int callback_id = downCbPtr->callbackId;
- DownloadInfoPtr diPtr = downCbPtr->instance->diMap[callback_id];
- if (!diPtr) {
- LoggerW("Download handle does not exist for callback id %d", callback_id);
+ int download_id = down_cb_ptr->download_id;
+ DownloadInfoPtr di_ptr = down_cb_ptr->instance->di_map[download_id];
+ if (!di_ptr) {
+ LoggerW("Download handle does not exist for callback id %d", download_id);
return FALSE;
}
- LoggerD("OnCanceled for callbackID %d Called", callback_id);
+ LoggerD("OnCanceled for callbackID %d Called", download_id);
- int ret = download_unset_state_changed_cb(diPtr->download_id);
+ int ret = download_unset_state_changed_cb(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE) {
LoggerE("%s", get_error_message(ret));
}
- ret = download_unset_progress_cb(diPtr->download_id);
+ ret = download_unset_progress_cb(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE) {
LoggerE("%s", get_error_message(ret));
}
- ret = download_destroy(diPtr->download_id);
+ ret = download_destroy(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE) {
LoggerE("%s", get_error_message(ret));
}
picojson::value::object out;
out["status"] = picojson::value("canceled");
- out["callbackId"] = picojson::value(static_cast<double>(callback_id));
+ out["downloadId"] = picojson::value(static_cast<double>(download_id));
+ out["listenerId"] = picojson::value(kDownloadManagerListenerId);
- Instance::PostMessage(downCbPtr->instance, picojson::value(out).serialize().c_str());
- // downCbPtr is freed in destructor, it prevent from crash if OnFinished state
+ Instance::PostMessage(down_cb_ptr->instance, picojson::value(out).serialize().c_str());
+ // down_cb_ptr is freed in destructor, it prevent from crash if OnFinished state
// was called after OnFinished or OnFailed
return FALSE;
}
download_error_e error;
picojson::object out;
- CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
+ CallbackPtr down_cb_ptr = static_cast<CallbackPtr>(user_data);
std::lock_guard<std::mutex> lock(instances_mutex_);
- if (!CheckInstance(downCbPtr->instance)) {
+ if (!CheckInstance(down_cb_ptr->instance)) {
return FALSE;
}
- int callback_id = downCbPtr->callbackId;
- DownloadInfoPtr diPtr = downCbPtr->instance->diMap[callback_id];
- if (!diPtr) {
- LoggerW("Download handle does not exist for callback id %d", callback_id);
+ int download_id = down_cb_ptr->download_id;
+ DownloadInfoPtr di_ptr = down_cb_ptr->instance->di_map[download_id];
+ if (!di_ptr) {
+ LoggerW("Download handle does not exist for callback id %d", download_id);
return FALSE;
}
- LoggerD("OnFailed for callbackID %d called", callback_id);
+ LoggerD("OnFailed for callbackID %d called", download_id);
- download_get_error(downCbPtr->downloadId, &error);
+ download_get_error(down_cb_ptr->native_download_id, &error);
if (DOWNLOAD_ERROR_NONE != error) {
int http_status = 0;
- int ret = download_get_http_status(downCbPtr->downloadId, &http_status);
+ int ret = download_get_http_status(down_cb_ptr->native_download_id, &http_status);
std::string error_message;
if (DOWNLOAD_ERROR_NONE != ret) {
LoggerE("Gathering HTTP status failed, default error message will be used");
("download_get_error error: %d (%s)", error, get_error_message(error)));
}
- int ret = download_unset_state_changed_cb(diPtr->download_id);
+ int ret = download_unset_state_changed_cb(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE) {
LoggerE("%s", get_error_message(ret));
}
- ret = download_unset_progress_cb(diPtr->download_id);
+ ret = download_unset_progress_cb(di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE) {
LoggerE("%s", get_error_message(ret));
}
- ret = download_destroy(diPtr->download_id);
+ ret = download_destroy(di_ptr->native_download_id);
if (DOWNLOAD_ERROR_NONE != ret) {
LoggerE("%s", get_error_message(ret));
}
- out["callbackId"] = picojson::value(static_cast<double>(downCbPtr->callbackId));
+ out["downloadId"] = picojson::value(static_cast<double>(down_cb_ptr->download_id));
+ out["listenerId"] = picojson::value(kDownloadManagerListenerId);
- Instance::PostMessage(downCbPtr->instance, picojson::value(out).serialize().c_str());
- // downCbPtr is freed in destructor, it prevent from crash if OnFinished state
+ Instance::PostMessage(down_cb_ptr->instance, picojson::value(out).serialize().c_str());
+ // down_cb_ptr is freed in destructor, it prevent from crash if OnFinished state
// was called after OnFinished or OnCanceled
return FALSE;
}
void DownloadInstance::progress_changed_cb(int download_id, long long unsigned received,
void* user_data) {
ScopeLogger();
- CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
- downCbPtr->received = received;
- downCbPtr->downloadId = download_id;
+ CallbackPtr down_cb_ptr = static_cast<CallbackPtr>(user_data);
+ down_cb_ptr->received = received;
+ down_cb_ptr->native_download_id = download_id;
- g_idle_add(OnProgressChanged, downCbPtr);
+ g_idle_add(OnProgressChanged, down_cb_ptr);
}
void DownloadInstance::DownloadManagerStart(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeDownload, &out);
- CHECK_EXIST(args, "callbackId", out)
+ CHECK_EXIST(args, "downloadId", out)
CHECK_EXIST(args, "url", out)
int ret;
std::string networkType;
- DownloadInfoPtr diPtr(new DownloadInfo);
+ DownloadInfoPtr di_ptr(new DownloadInfo);
- diPtr->callbackId = static_cast<int>(args.get("callbackId").get<double>());
- diPtr->url = args.get("url").is<std::string>() ? args.get("url").get<std::string>() : "";
+ di_ptr->download_id = static_cast<int>(args.get("downloadId").get<double>());
+ di_ptr->url = args.get("url").is<std::string>() ? args.get("url").get<std::string>() : "";
if (!args.get("destination").is<picojson::null>()) {
if (args.get("destination").is<std::string>() &&
args.get("destination").get<std::string>() != "") {
- diPtr->destination = args.get("destination").get<std::string>();
- diPtr->destination = common::FilesystemProvider::Create().GetRealPath(diPtr->destination);
+ di_ptr->destination = args.get("destination").get<std::string>();
+ di_ptr->destination = common::FilesystemProvider::Create().GetRealPath(di_ptr->destination);
}
}
if (!args.get("fileName").is<picojson::null>()) {
if (args.get("fileName").is<std::string>() && args.get("fileName").get<std::string>() != "") {
- diPtr->file_name = args.get("fileName").get<std::string>();
+ di_ptr->file_name = args.get("fileName").get<std::string>();
}
}
if ("CELLULAR" == networkType) {
network_support = cell_support;
network_available = cell_available;
- diPtr->network_type = DOWNLOAD_NETWORK_DATA_NETWORK;
+ di_ptr->network_type = DOWNLOAD_NETWORK_DATA_NETWORK;
} else if ("WIFI" == networkType) {
network_support = wifi_support;
network_available = wifi_available;
- diPtr->network_type = DOWNLOAD_NETWORK_WIFI;
+ di_ptr->network_type = DOWNLOAD_NETWORK_WIFI;
} else if (("ALL" == networkType) && (CONNECTION_TYPE_DISCONNECTED != connection_type)) {
network_support = true;
network_available = true;
- diPtr->network_type = DOWNLOAD_NETWORK_ALL;
+ di_ptr->network_type = DOWNLOAD_NETWORK_ALL;
} else {
LogAndReportError(
common::PlatformResult(common::ErrorCode::INVALID_VALUES_ERR,
return;
}
- CallbackPtr downCbPtr(new DownloadCallback);
+ CallbackPtr down_cb_ptr(new DownloadCallback);
- downCbPtr->callbackId = diPtr->callbackId;
- downCbPtr->instance = this;
+ down_cb_ptr->download_id = di_ptr->download_id;
+ down_cb_ptr->instance = this;
- download_callbacks[downCbPtr->callbackId] = downCbPtr;
+ download_callbacks[down_cb_ptr->download_id] = down_cb_ptr;
- ret = download_create(&diPtr->download_id);
+ ret = download_create(&di_ptr->native_download_id);
if (ret != DOWNLOAD_ERROR_NONE) {
LogAndReportError(convertError(ret), &out,
("download_create error: %d (%s)", ret, get_error_message(ret)));
return;
}
- ret = download_set_state_changed_cb(diPtr->download_id, OnStateChanged,
- static_cast<void*>(downCbPtr));
+ ret = download_set_state_changed_cb(di_ptr->native_download_id, OnStateChanged,
+ static_cast<void*>(down_cb_ptr));
if (ret != DOWNLOAD_ERROR_NONE) {
LogAndReportError(convertError(ret), &out, ("download_set_state_changed_cb error: %d (%s)", ret,
get_error_message(ret)));
return;
}
- ret = download_set_progress_cb(diPtr->download_id, progress_changed_cb,
- static_cast<void*>(downCbPtr));
+ ret = download_set_progress_cb(di_ptr->native_download_id, progress_changed_cb,
+ static_cast<void*>(down_cb_ptr));
if (ret != DOWNLOAD_ERROR_NONE) {
LogAndReportError(convertError(ret), &out,
("download_set_progress_cb error: %d (%s)", ret, get_error_message(ret)));
return;
}
- ret = download_set_url(diPtr->download_id, diPtr->url.c_str());
+ ret = download_set_url(di_ptr->native_download_id, di_ptr->url.c_str());
if (ret != DOWNLOAD_ERROR_NONE) {
LogAndReportError(convertError(ret), &out,
("download_set_url error: %d (%s)", ret, get_error_message(ret)));
return;
}
- if (diPtr->destination.size() != 0) {
- ret = download_set_destination(diPtr->download_id, diPtr->destination.c_str());
+ if (di_ptr->destination.size() != 0) {
+ ret = download_set_destination(di_ptr->native_download_id, di_ptr->destination.c_str());
if (ret != DOWNLOAD_ERROR_NONE) {
LogAndReportError(convertError(ret), &out,
("download_set_destination error: %d (%s)", ret, get_error_message(ret)));
}
}
- if (!diPtr->file_name.empty()) {
- ret = download_set_file_name(diPtr->download_id, diPtr->file_name.c_str());
+ if (!di_ptr->file_name.empty()) {
+ ret = download_set_file_name(di_ptr->native_download_id, di_ptr->file_name.c_str());
if (ret != DOWNLOAD_ERROR_NONE) {
LogAndReportError(convertError(ret), &out,
("download_set_file_name error: %d (%s)", ret, get_error_message(ret)));
}
}
- ret = download_set_network_type(diPtr->download_id, diPtr->network_type);
+ ret = download_set_network_type(di_ptr->native_download_id, di_ptr->network_type);
if (args.get("httpHeader").is<picojson::object>()) {
picojson::object obj = args.get("httpHeader").get<picojson::object>();
for (picojson::object::const_iterator it = obj.begin(); it != obj.end(); ++it) {
- download_add_http_header_field(diPtr->download_id, it->first.c_str(),
+ download_add_http_header_field(di_ptr->native_download_id, it->first.c_str(),
it->second.to_str().c_str());
}
}
- diMap[downCbPtr->callbackId] = diPtr;
+ di_map[down_cb_ptr->download_id] = di_ptr;
- ret = download_start(diPtr->download_id);
+ ret = download_start(di_ptr->native_download_id);
if (ret == DOWNLOAD_ERROR_NONE) {
ReportSuccess(out);
free(mimetype);
}
-bool DownloadInstance::GetDownloadID(const int callback_id, int& download_id) {
+bool DownloadInstance::GetDownloadID(const int download_id, int& native_download_id) {
ScopeLogger();
- if (diMap.find(callback_id) != diMap.end()) {
- download_id = diMap.find(callback_id)->second->download_id;
+ if (di_map.find(download_id) != di_map.end()) {
+ native_download_id = di_map.find(download_id)->second->native_download_id;
} else {
return false;
}
return true;
}
-void DownloadInstance::DownloadManagerGetdownloadrequest(const picojson::value& args,
- picojson::object& out) {
- ScopeLogger();
- // Nothing to do
-}
-
-void DownloadInstance::DownloadManagerSetlistener(const picojson::value& args,
- picojson::object& out) {
- ScopeLogger();
- // Nothing to do
-}
-
#undef CHECK_EXIST
} // namespace download
projects / platform / core / api / webapi-plugins.git / blobdiff