* limitations under the License.
*/
-var JSON_ = xwalk.JSON;
var privUtils_ = xwalk.utils;
var validator_ = xwalk.utils.validator;
var types_ = validator_.Types;
-var check_ = xwalk.utils.type;
var converter_ = xwalk.utils.converter;
+var native_ = new xwalk.utils.NativeManager(extension);
+var DOWNLOAD_MANAGER_LISTENER_ID = 'DownloadManagerListener';
-var callbackId = 0;
+var downloadId = 0;
var callbacks = {};
var requests = {};
-
-extension.setMessageListener(function(json) {
-
- var result = JSON_.parse(json);
- var callback = callbacks[result.callbackId];
- //privUtils_.log("PostMessage received: " + result.status);
+function DownloadManagerChangeCallback(result) {
+ var callback = callbacks[result.downloadId];
if (!callback) {
- privUtils_.log('Ignoring unknown callback: ' + result.callbackId);
+ privUtils_.log('Ignoring unknown callback: ' + result.downloadId);
return;
}
setTimeout(function() {
if (callback.onprogress) {
var receivedSize = result.receivedSize;
var totalSize = result.totalSize;
- callback.onprogress(result.callbackId, receivedSize, totalSize);
+ callback.onprogress(result.downloadId, receivedSize, totalSize);
}
} else if (result.status == 'paused') {
if (callback.onpaused) {
- callback.onpaused(result.callbackId);
+ callback.onpaused(result.downloadId);
}
} else if (result.status == 'canceled') {
if (callback.oncanceled) {
- callback.oncanceled(result.callbackId);
+ callback.oncanceled(result.downloadId);
+ delete callbacks[result.downloadId];
}
} else if (result.status == 'completed') {
if (callback.oncompleted) {
var fullPath = result.fullPath;
- callback.oncompleted(result.callbackId, fullPath);
+ callback.oncompleted(result.downloadId, fullPath);
+ delete callbacks[result.downloadId];
}
} else if (result.status == 'error') {
if (callback.onfailed) {
- callback.onfailed(result.callbackId,
+ callback.onfailed(result.downloadId,
new WebAPIException(result.error));
+ delete callbacks[result.downloadId];
}
}
}, 0);
-});
-
-function nextCallbackId() {
- return ++callbackId;
}
-function callNative(cmd, args) {
- var json = {'cmd': cmd, 'args': args};
- var argjson = JSON_.stringify(json);
- var resultString = extension.internal.sendSyncMessage(argjson);
- var result = JSON_.parse(resultString);
-
- if (typeof result !== 'object') {
- throw new WebAPIException(WebAPIException.UNKNOWN_ERR);
- }
-
- if (result.status == 'success') {
- if (result.result) {
- return result.result;
- }
- return true;
- } else if (result.status == 'error') {
- var err = result.error;
- if (err) {
- throw new WebAPIException(err);
- }
- return false;
- }
-}
-
-
-function callNativeWithCallback(cmd, args, callback) {
- if (callback) {
- var id = nextCallbackId();
- args.callbackId = id;
- callbacks[id] = callback;
- }
-
- return callNative(cmd, args);
+function nextDownloadId() {
+ return ++downloadId;
}
function SetReadOnlyProperty(obj, n, v) {
'fileName': args.downloadRequest.fileName,
'networkType': args.downloadRequest.networkType,
'httpHeader': args.downloadRequest.httpHeader,
- 'callbackId': nextCallbackId()
+ 'downloadId': nextDownloadId()
};
if (args.downloadCallback) {
- this.setListener(nativeParam.callbackId, args.downloadCallback);
+ this.setListener(nativeParam.downloadId, args.downloadCallback);
}
- try {
- callNative('DownloadManager_start', nativeParam);
- } catch (e) {
- if ('NetworkError' === e.name) {
+ var result = native_.callSync('DownloadManager_start', nativeParam);
+
+ if (native_.isFailure(result)) {
+ if ('NetworkError' === result.error.name) {
return -1;
}
- throw e;
+ throw native_.getErrorObject(result);
}
- requests[nativeParam.callbackId] = args.downloadRequest;
+ requests[nativeParam.downloadId] = args.downloadRequest;
- return nativeParam.callbackId;
+ return nativeParam.downloadId;
};
DownloadManager.prototype.cancel = function() {
throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR,
'the identifier does not match any download operation in progress');
- try {
- callNative('DownloadManager_cancel', nativeParam);
- } catch (e) {
- throw e;
+ var result = native_.callSync('DownloadManager_cancel', nativeParam);
+
+ if (native_.isFailure(result)) {
+ throw native_.getErrorObject(result);
}
};
throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR,
'the identifier does not match any download operation in progress');
- try {
- callNative('DownloadManager_pause', nativeParam);
- } catch (e) {
- throw e;
+ var result = native_.callSync('DownloadManager_pause', nativeParam);
+
+ if (native_.isFailure(result)) {
+ throw native_.getErrorObject(result);
}
};
throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR,
'the identifier does not match any download operation in progress');
- try {
- callNative('DownloadManager_resume', nativeParam);
- } catch (e) {
- throw e;
+ var result = native_.callSync('DownloadManager_resume', nativeParam);
+
+ if (native_.isFailure(result)) {
+ throw native_.getErrorObject(result);
}
};
throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR,
'the identifier does not match any download operation in progress');
- try {
- return callNative('DownloadManager_getState', nativeParam);
- } catch (e) {
- throw e;
+ var result = native_.callSync('DownloadManager_getState', nativeParam);
+
+ if (native_.isSuccess(result)) {
+ return native_.getResultObject(result);
+ } else {
+ throw native_.getErrorObject(result);
}
};
throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR,
'the identifier does not match any download operation in progress');
- try {
- return callNative('DownloadManager_getMIMEType', nativeParam);
- } catch (e) {
- throw e;
+ var result = native_.callSync('DownloadManager_getMIMEType', nativeParam);
+
+ if (native_.isSuccess(result)) {
+ return native_.getResultObject(result);
+ } else {
+ throw native_.getErrorObject(result);
}
};
'values' : ['onprogress', 'onpaused', 'oncanceled', 'oncompleted', 'onfailed']}
]);
+ if (!native_.isListenerSet(DOWNLOAD_MANAGER_LISTENER_ID)) {
+ native_.addListener(DOWNLOAD_MANAGER_LISTENER_ID, DownloadManagerChangeCallback);
+ }
callbacks[args.downloadId] = args.downloadCallback;
};
-
-
-exports = new DownloadManager();
-
+exports = new DownloadManager();
\ No newline at end of file
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);
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);
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: %llu", 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 / commitdiff