From f5361542dadd1b1930dcf8d1000a967f45fa9b83 Mon Sep 17 00:00:00 2001 From: Andrzej Popowski Date: Mon, 19 Oct 2015 13:17:01 +0200 Subject: [PATCH] [Download] - Fixing error handling Change-Id: I6645a306dc35c346cd5be70ffb38c00cd1bb35a7 Signed-off-by: Andrzej Popowski --- src/download/download_instance.cc | 515 ++++++++++++++---------------- src/download/download_instance.h | 7 +- 2 files changed, 240 insertions(+), 282 deletions(-) diff --git a/src/download/download_instance.cc b/src/download/download_instance.cc index fc493643..b507b094 100755 --- a/src/download/download_instance.cc +++ b/src/download/download_instance.cc @@ -20,9 +20,9 @@ #include +#include "common/tools.h" #include "common/picojson.h" #include "common/logger.h" -#include "common/platform_exception.h" #include "common/typeutil.h" #include "common/virtual_fs.h" @@ -32,18 +32,6 @@ namespace download { std::vector DownloadInstance::instances_; std::mutex DownloadInstance::instances_mutex_; -using common::NotFoundException; -using common::UnknownException; -using common::NetworkException; -using common::SecurityException; -using common::QuotaExceededException; -using common::NotSupportedException; -using common::InvalidStateException; -using common::IOException; -using common::InvalidValuesException; -using common::ServiceNotAvailableException; -using common::TypeMismatchException; - DownloadInstance::DownloadInstance() { LoggerD("Entered"); using std::placeholders::_1; @@ -68,8 +56,8 @@ DownloadInstance::DownloadInstance() { DownloadInstance::~DownloadInstance() { LoggerD("Entered"); int ret; - for (DownloadCallbackMap::iterator it = downCbMap.begin(); - it != downCbMap.end(); ++it) { + 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); @@ -112,16 +100,110 @@ bool DownloadInstance::CheckInstance(DownloadInstance* instance) { return false; } +common::PlatformResult DownloadInstance::convertError(int err) { + char* error = get_error_message(err); + LoggerE("%s",error); + switch (err) { + case DOWNLOAD_ERROR_INVALID_PARAMETER: + return common::PlatformResult(common::ErrorCode::INVALID_VALUES_ERR, + error); + case DOWNLOAD_ERROR_OUT_OF_MEMORY: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_NETWORK_UNREACHABLE: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_CONNECTION_TIMED_OUT: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_NO_SPACE: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_PERMISSION_DENIED: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_NOT_SUPPORTED: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_INVALID_STATE: + return common::PlatformResult(common::ErrorCode::INVALID_VALUES_ERR, + error); + case DOWNLOAD_ERROR_CONNECTION_FAILED: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_INVALID_URL: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_INVALID_DESTINATION: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_TOO_MANY_DOWNLOADS: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_QUEUE_FULL: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_ALREADY_COMPLETED: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_FILE_ALREADY_EXISTS: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_CANNOT_RESUME: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_FIELD_NOT_FOUND: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_TOO_MANY_REDIRECTS: + return common::PlatformResult( + common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_UNHANDLED_HTTP_CODE: + return common::PlatformResult( + common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_REQUEST_TIMEOUT: + return common::PlatformResult( + common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_RESPONSE_TIMEOUT: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_SYSTEM_DOWN: + return common::PlatformResult( + common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_ID_NOT_FOUND: + return common::PlatformResult( + common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_INVALID_NETWORK_TYPE: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_NO_DATA: + return common::PlatformResult( + common::ErrorCode::UNKNOWN_ERR, + error); + case DOWNLOAD_ERROR_IO_ERROR: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + error); + default: + return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, + "Unknown error."); + } +} + #define CHECK_EXIST(args, name, out) \ if (!args.contains(name)) {\ - ReportError(TypeMismatchException(name" is required argument"), out);\ + ReportError(common::PlatformResult(common::ErrorCode::TYPE_MISMATCH_ERR, name" is required argument"), &out);\ return;\ } void DownloadInstance::OnStateChanged(int download_id, download_state_e state, void* user_data) { LoggerD("Entered"); - DownloadCallback* downCbPtr = static_cast(user_data); + CallbackPtr downCbPtr = static_cast(user_data); downCbPtr->state = state; downCbPtr->downloadId = download_id; @@ -155,7 +237,7 @@ void DownloadInstance::OnStateChanged(int download_id, gboolean DownloadInstance::OnProgressChanged(void* user_data) { LoggerD("Entered"); - DownloadCallback* downCbPtr = static_cast(user_data); + CallbackPtr downCbPtr = static_cast(user_data); std::lock_guard lock(instances_mutex_); if (!CheckInstance(downCbPtr->instance)) { return FALSE; @@ -171,7 +253,7 @@ gboolean DownloadInstance::OnProgressChanged(void* user_data) { picojson::value(static_cast(downCbPtr->received)); out["totalSize"] = picojson::value(static_cast(diPtr->file_size)); - SLoggerD("OnProgressChanged for callbackId %d Called: Received: %ld", + LoggerD("OnProgressChanged for callbackId %d Called: Received: %ld", downCbPtr->callbackId, downCbPtr->received); picojson::value v = picojson::value(out); @@ -184,7 +266,7 @@ void DownloadInstance::OnStart(int download_id, void* user_data) { LoggerD("Entered"); unsigned long long totalSize; - DownloadCallback* downCbPtr = static_cast(user_data); + CallbackPtr downCbPtr = static_cast(user_data); std::lock_guard lock(instances_mutex_); if (!CheckInstance(downCbPtr->instance)) { return; @@ -203,30 +285,43 @@ gboolean DownloadInstance::OnFinished(void* user_data) { LoggerD("Entered"); char* fullPath = NULL; - DownloadCallback* downCbPtr = static_cast(user_data); + CallbackPtr downCbPtr = static_cast(user_data); std::lock_guard lock(instances_mutex_); if (!CheckInstance(downCbPtr->instance)) { return FALSE; } - DownloadInfoPtr diPtr = downCbPtr->instance->diMap[downCbPtr->callbackId]; + int callback_id = downCbPtr->callbackId; + DownloadInfoPtr diPtr = downCbPtr->instance->diMap[callback_id]; - SLoggerD("OnFinished for callbackID %d Called", downCbPtr->callbackId); + LoggerD("OnFinished for callbackID %d Called", callback_id); - download_get_downloaded_file_path(downCbPtr->downloadId, &fullPath); + picojson::value::object out; - download_unset_state_changed_cb(diPtr->download_id); - download_unset_progress_cb(diPtr->download_id); - download_destroy(diPtr->download_id); + int ret = download_get_downloaded_file_path(downCbPtr->downloadId, &fullPath); + if (ret != DOWNLOAD_ERROR_NONE) { + common::tools::ReportError(convertError(ret), &out); + } else { + ret = download_unset_state_changed_cb(diPtr->download_id); + if (ret != DOWNLOAD_ERROR_NONE) { + LoggerW("%s", get_error_message(ret)); + } + ret = download_unset_progress_cb(diPtr->download_id); + if (ret != DOWNLOAD_ERROR_NONE) { + LoggerW("%s", get_error_message(ret)); + } + ret = download_destroy(diPtr->download_id); + if (ret != DOWNLOAD_ERROR_NONE) { + LoggerW("%s", get_error_message(ret)); + } + out["status"] = picojson::value("completed"); + } - picojson::value::object out; - out["status"] = picojson::value("completed"); - out["callbackId"] = - picojson::value(static_cast(downCbPtr->callbackId)); + out["callbackId"] = picojson::value(static_cast(callback_id)); out["fullPath"] = picojson::value(common::VirtualFs::GetInstance().GetVirtualPath(fullPath)); Instance::PostMessage(downCbPtr->instance, picojson::value(out).serialize().c_str()); - downCbPtr->instance->downCbMap.erase(downCbPtr->callbackId); + downCbPtr->instance->download_callbacks.erase(callback_id); delete (downCbPtr); free(fullPath); @@ -236,20 +331,21 @@ gboolean DownloadInstance::OnFinished(void* user_data) { gboolean DownloadInstance::OnPaused(void* user_data) { LoggerD("Entered"); - DownloadCallback* downCbPtr = static_cast(user_data); + CallbackPtr downCbPtr = static_cast(user_data); std::lock_guard lock(instances_mutex_); if (!CheckInstance(downCbPtr->instance)) { return FALSE; } - DownloadInfoPtr diPtr = downCbPtr->instance->diMap[downCbPtr->callbackId]; + int callback_id = downCbPtr->callbackId; + DownloadInfoPtr diPtr = downCbPtr->instance->diMap[callback_id]; - SLoggerD("OnPaused for callbackID %d Called", downCbPtr->callbackId); + LoggerD("OnPaused for callbackID %d Called", callback_id); picojson::value::object out; out["status"] = picojson::value("paused"); out["callbackId"] = - picojson::value(static_cast(downCbPtr->callbackId)); + picojson::value(static_cast(callback_id)); Instance::PostMessage(downCbPtr->instance, picojson::value(out).serialize().c_str()); return FALSE; @@ -257,27 +353,39 @@ gboolean DownloadInstance::OnPaused(void* user_data) { gboolean DownloadInstance::OnCanceled(void* user_data) { LoggerD("Entered"); - DownloadCallback* downCbPtr = static_cast(user_data); + CallbackPtr downCbPtr = static_cast(user_data); std::lock_guard lock(instances_mutex_); if (!CheckInstance(downCbPtr->instance)) { return FALSE; } - DownloadInfoPtr diPtr = downCbPtr->instance->diMap[downCbPtr->callbackId]; + int callback_id = downCbPtr->callbackId; + DownloadInfoPtr diPtr = downCbPtr->instance->diMap[callback_id]; + + LoggerD("OnCanceled for callbackID %d Called", callback_id); - SLoggerD("OnCanceled for callbackID %d Called", downCbPtr->callbackId); + int ret = download_unset_state_changed_cb(diPtr->download_id); + if (ret != DOWNLOAD_ERROR_NONE) { + LoggerE("%s", get_error_message(ret)); + } + + ret = download_unset_progress_cb(diPtr->download_id); + if (ret != DOWNLOAD_ERROR_NONE) { + LoggerE("%s", get_error_message(ret)); + } - download_unset_state_changed_cb(diPtr->download_id); - download_unset_progress_cb(diPtr->download_id); - download_destroy(diPtr->download_id); + ret = download_destroy(diPtr->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(downCbPtr->callbackId)); + picojson::value(static_cast(callback_id)); Instance::PostMessage(downCbPtr->instance, picojson::value(out).serialize().c_str()); - downCbPtr->instance->downCbMap.erase(downCbPtr->callbackId); + downCbPtr->instance->download_callbacks.erase(callback_id); delete (downCbPtr); return FALSE; @@ -288,7 +396,7 @@ gboolean DownloadInstance::OnFailed(void* user_data) { download_error_e error; picojson::object out; - DownloadCallback* downCbPtr = static_cast(user_data); + CallbackPtr downCbPtr = static_cast(user_data); std::lock_guard lock(instances_mutex_); if (!CheckInstance(downCbPtr->instance)) { return FALSE; @@ -296,109 +404,12 @@ gboolean DownloadInstance::OnFailed(void* user_data) { DownloadInstance* instance = downCbPtr->instance; - SLoggerD("OnFailed for callbackID %d Called", downCbPtr->callbackId); + LoggerD("OnFailed for callbackID %d Called", downCbPtr->callbackId); download_get_error(downCbPtr->downloadId, &error); - switch (error) { - case DOWNLOAD_ERROR_INVALID_PARAMETER: - instance->ReportError(NotFoundException("not found"), out); - break; - case DOWNLOAD_ERROR_OUT_OF_MEMORY: - instance->ReportError(UnknownException("Out of memory"), out); - break; - case DOWNLOAD_ERROR_NETWORK_UNREACHABLE: - instance->ReportError(NetworkException("Network is unreachable"), out); - break; - case DOWNLOAD_ERROR_CONNECTION_TIMED_OUT: - instance->ReportError(NetworkException("HTTP session timeout"), out); - break; - case DOWNLOAD_ERROR_NO_SPACE: - instance->ReportError(QuotaExceededException( - "No space left on device"), out); - break; - case DOWNLOAD_ERROR_PERMISSION_DENIED: - instance->ReportError(SecurityException( - "The application does not have the privilege to call this method."), - out); - break; - case DOWNLOAD_ERROR_NOT_SUPPORTED: - instance->ReportError(NotSupportedException("Not supported"), out); - break; - case DOWNLOAD_ERROR_INVALID_STATE: - instance->ReportError(InvalidStateException("Invalid state"), out); - break; - case DOWNLOAD_ERROR_CONNECTION_FAILED: - instance->ReportError(NetworkException("Connection failed"), out); - break; - case DOWNLOAD_ERROR_INVALID_URL: - instance->ReportError(InvalidValuesException("Invalid URL"), out); - break; - case DOWNLOAD_ERROR_INVALID_DESTINATION: - instance->ReportError(InvalidValuesException( - "Invalid destination"), out); - break; - case DOWNLOAD_ERROR_TOO_MANY_DOWNLOADS: - instance->ReportError(QuotaExceededException( - "Too many simultaneous downloads"), out); - break; - case DOWNLOAD_ERROR_QUEUE_FULL: - instance->ReportError(QuotaExceededException( - "Download server queue is full"), out); - break; - case DOWNLOAD_ERROR_ALREADY_COMPLETED: - instance->ReportError(InvalidStateException( - "The download is already completed"), out); - break; - case DOWNLOAD_ERROR_FILE_ALREADY_EXISTS: - instance->ReportError(IOException( - "Failed to rename the downloaded file"), out); - break; - case DOWNLOAD_ERROR_CANNOT_RESUME: - instance->ReportError(NotSupportedException("Cannot resume"), out); - break; - case DOWNLOAD_ERROR_FIELD_NOT_FOUND: - instance->ReportError(NotFoundException( - "Specified field not found"), out); - break; - case DOWNLOAD_ERROR_TOO_MANY_REDIRECTS: - instance->ReportError(NetworkException( - "Too many redirects from HTTP response header"), out); - break; - case DOWNLOAD_ERROR_UNHANDLED_HTTP_CODE: - instance->ReportError(NetworkException( - "The download cannot handle the HTTP status value"), out); - break; - case DOWNLOAD_ERROR_REQUEST_TIMEOUT: - instance->ReportError(NetworkException( - "No action after client creates a download ID"), out); - break; - case DOWNLOAD_ERROR_RESPONSE_TIMEOUT: - instance->ReportError(NetworkException( - "No call to start API for some time although the download is created"), - out); - break; - case DOWNLOAD_ERROR_SYSTEM_DOWN: - instance->ReportError(ServiceNotAvailableException( - "No response from client after rebooting download daemon"), out); - break; - case DOWNLOAD_ERROR_ID_NOT_FOUND: - instance->ReportError(NotFoundException( - "Download ID does not exist in download service module"), out); - break; - case DOWNLOAD_ERROR_INVALID_NETWORK_TYPE: - instance->ReportError(InvalidValuesException( - "Network bonding is set but network type is not set as ALL"), out); - break; - case DOWNLOAD_ERROR_NO_DATA: - instance->ReportError(NotFoundException( - "No data because the set API is not called"), out); - break; - case DOWNLOAD_ERROR_IO_ERROR: - instance->ReportError(IOException("Internal I/O error"), out); - break; - case DOWNLOAD_ERROR_NONE: - break; + if (DOWNLOAD_ERROR_NONE != error) { + common::tools::ReportError(convertError(error), &out); } out["callbackId"] = @@ -411,7 +422,7 @@ gboolean DownloadInstance::OnFailed(void* user_data) { void DownloadInstance::progress_changed_cb (int download_id, long long unsigned received, void* user_data) { LoggerD("Entered"); - DownloadCallback* downCbPtr = static_cast(user_data); + CallbackPtr downCbPtr = static_cast(user_data); downCbPtr->received = received; downCbPtr->downloadId = download_id; @@ -492,15 +503,14 @@ void DownloadInstance::DownloadManagerStart } else { LoggerE("The input parameter contains an invalid network type"); ReportError( - InvalidValuesException( - "The input parameter contains an invalid network type."), - out); + common::PlatformResult(common::ErrorCode::INVALID_VALUES_ERR, + "The input parameter contains an invalid network type."), + &out); return; } if (!network_support) { - SLoggerE("Requested network type (%s) is not supported.", networkType.c_str()); - LoggerE("Requested network type is not supported"); + LoggerE("Requested network type (%s) is not supported.", networkType.c_str()); ReportError( common::PlatformResult(common::ErrorCode::NOT_SUPPORTED_ERR, "The networkType of the given DownloadRequest " @@ -510,8 +520,7 @@ void DownloadInstance::DownloadManagerStart } if (!network_available) { - SLoggerE("Requested network type (%s) is not available.", networkType.c_str()); - LoggerE("Requested network type is not available"); + LoggerE("Requested network type (%s) is not available.", networkType.c_str()); ReportError( common::PlatformResult(common::ErrorCode::NETWORK_ERR, "The networkType of the given DownloadRequest " @@ -520,29 +529,59 @@ void DownloadInstance::DownloadManagerStart return; } - DownloadCallback* downCbPtr(new DownloadCallback); + CallbackPtr downCbPtr(new DownloadCallback); downCbPtr->callbackId = diPtr->callbackId; downCbPtr->instance = this; - downCbMap[downCbPtr->callbackId] = downCbPtr; + download_callbacks[downCbPtr->callbackId] = downCbPtr; ret = download_create(&diPtr->download_id); - ret = - download_set_state_changed_cb - (diPtr->download_id, OnStateChanged, static_cast(downCbPtr)); - ret = - download_set_progress_cb - (diPtr->download_id, progress_changed_cb, static_cast(downCbPtr)); - ret = - download_set_url(diPtr->download_id, diPtr->url.c_str()); + if (ret != DOWNLOAD_ERROR_NONE) { + LoggerE("%s", get_error_message(ret)); + common::tools::ReportError(convertError(ret), &out); + return; + } + + ret = download_set_state_changed_cb (diPtr->download_id, OnStateChanged, + static_cast(downCbPtr)); + if (ret != DOWNLOAD_ERROR_NONE) { + LoggerE("%s", get_error_message(ret)); + common::tools::ReportError(convertError(ret), &out); + return; + } + + ret = download_set_progress_cb (diPtr->download_id, progress_changed_cb, + static_cast(downCbPtr)); + if (ret != DOWNLOAD_ERROR_NONE) { + LoggerE("%s", get_error_message(ret)); + common::tools::ReportError(convertError(ret), &out); + return; + } + + ret = download_set_url(diPtr->download_id, diPtr->url.c_str()); + if (ret != DOWNLOAD_ERROR_NONE) { + LoggerE("%s", get_error_message(ret)); + common::tools::ReportError(convertError(ret), &out); + return; + } if (diPtr->destination.size() != 0) { ret = download_set_destination(diPtr->download_id, diPtr->destination.c_str()); + if (ret != DOWNLOAD_ERROR_NONE) { + LoggerE("%s", get_error_message(ret)); + common::tools::ReportError(convertError(ret), &out); + return; + } } if (!diPtr->file_name.empty()) { ret = download_set_file_name(diPtr->download_id, diPtr->file_name.c_str()); + if (ret != DOWNLOAD_ERROR_NONE) { + LoggerE("%s", get_error_message(ret)); + common::tools::ReportError(convertError(ret), &out); + return; + } } ret = download_set_network_type(diPtr->download_id, diPtr->network_type); @@ -560,32 +599,12 @@ void DownloadInstance::DownloadManagerStart ret = download_start(diPtr->download_id); - if (ret == DOWNLOAD_ERROR_NONE) + if (ret == DOWNLOAD_ERROR_NONE) { ReportSuccess(out); - else if (ret == DOWNLOAD_ERROR_INVALID_PARAMETER) - ReportError(InvalidValuesException - ("The input parameter contains an invalid value."), out); - else if (ret == DOWNLOAD_ERROR_OUT_OF_MEMORY) - ReportError(UnknownException("Out of memory"), out); - else if (ret == DOWNLOAD_ERROR_INVALID_STATE) - ReportError(InvalidValuesException("Invalid state"), out); - else if (ret == DOWNLOAD_ERROR_IO_ERROR) - ReportError(UnknownException("Internal I/O error"), out); - else if (ret == DOWNLOAD_ERROR_INVALID_URL) - ReportError(InvalidValuesException( - "The input parameter contains an invalid url."), out); - else if (ret == DOWNLOAD_ERROR_INVALID_DESTINATION) - ReportError(InvalidValuesException( - "The input parameter contains an invalid destination."), out); - else if (ret == DOWNLOAD_ERROR_ID_NOT_FOUND) - ReportError(InvalidValuesException("No such a download ID found"), out); - else if (ret == DOWNLOAD_ERROR_QUEUE_FULL) - ReportError(UnknownException("Download server queue is full"), out); - else if (ret == DOWNLOAD_ERROR_PERMISSION_DENIED) - ReportError(SecurityException( - "The application does not have the privilege to call this method."), out); - else - ReportError(UnknownException("Unknown Error"), out); + } else { + LoggerE("%s", get_error_message(ret)); + common::tools::ReportError(convertError(ret), &out); + } } void DownloadInstance::DownloadManagerCancel @@ -598,29 +617,19 @@ void DownloadInstance::DownloadManagerCancel if (!GetDownloadID(callbackId, downloadId)) { LoggerE("The identifier does not match any download operation in progress"); - ReportError(NotFoundException - ("The identifier does not match any download operation in progress"), - out); + ReportError(common::PlatformResult(common::ErrorCode::NOT_FOUND_ERR, + "The identifier does not match any download operation in progress"), + &out); return; } ret = download_cancel(downloadId); - if (ret == DOWNLOAD_ERROR_NONE) + if (ret == DOWNLOAD_ERROR_NONE) { ReportSuccess(out); - else if (ret == DOWNLOAD_ERROR_INVALID_PARAMETER) - ReportError(InvalidValuesException - ("The input parameter contains an invalid value."), out); - else if (ret == DOWNLOAD_ERROR_OUT_OF_MEMORY) - ReportError(UnknownException("Out of memory"), out); - else if (ret == DOWNLOAD_ERROR_INVALID_STATE) - ReportError(InvalidValuesException("Invalid state"), out); - else if (ret == DOWNLOAD_ERROR_IO_ERROR) - ReportError(UnknownException("Internal I/O error"), out); - else if (ret == DOWNLOAD_ERROR_PERMISSION_DENIED) - ReportError(UnknownException("Permission denied"), out); - else - ReportError(UnknownException("Unknown Error"), out); + } else { + common::tools::ReportError(convertError(ret), &out); + } } void DownloadInstance::DownloadManagerPause @@ -633,29 +642,19 @@ void DownloadInstance::DownloadManagerPause if (!GetDownloadID(callbackId, downloadId)) { LoggerE("The identifier does not match any download operation in progress"); - ReportError(NotFoundException( + ReportError(common::PlatformResult(common::ErrorCode::NOT_FOUND_ERR, "The identifier does not match any download operation in progress"), - out); + &out); return; } ret = download_pause(downloadId); - if (ret == DOWNLOAD_ERROR_NONE) + if (ret == DOWNLOAD_ERROR_NONE) { ReportSuccess(out); - else if (ret == DOWNLOAD_ERROR_INVALID_PARAMETER) - ReportError(InvalidValuesException( - "The input parameter contains an invalid value."), out); - else if (ret == DOWNLOAD_ERROR_OUT_OF_MEMORY) - ReportError(UnknownException("Out of memory"), out); - else if (ret == DOWNLOAD_ERROR_INVALID_STATE) - ReportError(InvalidValuesException("Invalid state"), out); - else if (ret == DOWNLOAD_ERROR_IO_ERROR) - ReportError(UnknownException("Internal I/O error"), out); - else if (ret == DOWNLOAD_ERROR_PERMISSION_DENIED) - ReportError(UnknownException("Permission denied"), out); - else - ReportError(UnknownException("Unknown Error"), out); + } else { + common::tools::ReportError(convertError(ret), &out); + } } void DownloadInstance::DownloadManagerResume @@ -667,41 +666,21 @@ void DownloadInstance::DownloadManagerResume int callbackId = static_cast(args.get("downloadId").get()); if (!GetDownloadID(callbackId, downloadId)) { - ReportError(NotFoundException - ("The identifier does not match any download operation in progress"), - out); + ReportError(common::PlatformResult(common::ErrorCode::NOT_FOUND_ERR, + "The identifier does not match any download operation in progress"), + &out); return; } ret = download_start(downloadId); - if (ret == DOWNLOAD_ERROR_NONE) + if (ret == DOWNLOAD_ERROR_NONE) { ReportSuccess(out); - else if (ret == DOWNLOAD_ERROR_INVALID_PARAMETER) - ReportError(InvalidValuesException( - "The input parameter contains an invalid value."), out); - else if (ret == DOWNLOAD_ERROR_OUT_OF_MEMORY) - ReportError(UnknownException("Out of memory"), out); - else if (ret == DOWNLOAD_ERROR_INVALID_STATE) - ReportError(InvalidValuesException("Invalid state"), out); - else if (ret == DOWNLOAD_ERROR_IO_ERROR) - ReportError(UnknownException("Internal I/O error"), out); - else if (ret == DOWNLOAD_ERROR_INVALID_URL) - ReportError(InvalidValuesException( - "The input parameter contains an invalid url."), out); - else if (ret == DOWNLOAD_ERROR_INVALID_DESTINATION) - ReportError(InvalidValuesException( - "The input parameter contains an invalid destination."), out); - else if (ret == DOWNLOAD_ERROR_ID_NOT_FOUND) - ReportError(InvalidValuesException("No such a download ID found"), out); - else if (ret == DOWNLOAD_ERROR_QUEUE_FULL) - ReportError(UnknownException("Download server queue is full"), out); - else if (ret == DOWNLOAD_ERROR_PERMISSION_DENIED) - ReportError(SecurityException( - "Application does not have the privilege to call this method."), out); - else - ReportError(UnknownException("Unknown Error"), out); + } else { + common::tools::ReportError(convertError(ret), &out); + } } + void DownloadInstance::DownloadManagerGetstate (const picojson::value& args, picojson::object& out) { LoggerD("Entered"); @@ -714,9 +693,9 @@ void DownloadInstance::DownloadManagerGetstate if (!GetDownloadID(callbackId, downloadId)) { LoggerE("The identifier does not match any download operation in progress"); - ReportError(NotFoundException - ("The identifier does not match any download operation in progress"), - out); + ReportError(common::PlatformResult(common::ErrorCode::NOT_FOUND_ERR, + "The identifier does not match any download operation in progress"), + &out); return; } @@ -750,19 +729,8 @@ void DownloadInstance::DownloadManagerGetstate } ReportSuccess(picojson::value(stateValue), out); - } else if (ret == DOWNLOAD_ERROR_INVALID_PARAMETER) { - ReportError(InvalidValuesException( - "The input parameter contains an invalid value."), out); - } else if (ret == DOWNLOAD_ERROR_OUT_OF_MEMORY) { - ReportError(UnknownException("Out of memory"), out); - } else if (ret == DOWNLOAD_ERROR_INVALID_STATE) { - ReportError(InvalidValuesException("Invalid state"), out); - } else if (ret == DOWNLOAD_ERROR_IO_ERROR) { - ReportError(UnknownException("Internal I/O error"), out); - } else if (ret == DOWNLOAD_ERROR_PERMISSION_DENIED) { - ReportError(UnknownException("Permission denied"), out); } else { - ReportError(UnknownException("Unknown Error"), out); + common::tools::ReportError(convertError(ret), &out); } } @@ -777,9 +745,9 @@ void DownloadInstance::DownloadManagerGetmimetype int callbackId = static_cast(args.get("downloadId").get()); if (!GetDownloadID(callbackId, downloadId)) { - ReportError(NotFoundException - ("The identifier does not match any download operation in progress"), - out); + ReportError(common::PlatformResult(common::ErrorCode::NOT_FOUND_ERR, + "The identifier does not match any download operation in progress"), + &out); return; } @@ -787,19 +755,8 @@ void DownloadInstance::DownloadManagerGetmimetype if (ret == DOWNLOAD_ERROR_NONE) { ReportSuccess(picojson::value(mimetype), out); - } else if (ret == DOWNLOAD_ERROR_INVALID_PARAMETER) { - ReportError(InvalidValuesException( - "The input parameter contains an invalid value."), out); - } else if (ret == DOWNLOAD_ERROR_OUT_OF_MEMORY) { - ReportError(UnknownException("Out of memory"), out); - } else if (ret == DOWNLOAD_ERROR_INVALID_STATE) { - ReportError(InvalidValuesException("Invalid state"), out); - } else if (ret == DOWNLOAD_ERROR_IO_ERROR) { - ReportError(UnknownException("Internal I/O error"), out); - } else if (ret == DOWNLOAD_ERROR_PERMISSION_DENIED) { - ReportError(UnknownException("Permission denied"), out); } else { - ReportError(UnknownException("Unknown Error"), out); + common::tools::ReportError(convertError(ret), &out); } free(mimetype); } diff --git a/src/download/download_instance.h b/src/download/download_instance.h index 53d58d31..6af32da9 100755 --- a/src/download/download_instance.h +++ b/src/download/download_instance.h @@ -27,7 +27,6 @@ #include #include #include - #include "common/extension.h" template @@ -65,6 +64,7 @@ class DownloadInstance : public common::ParsedInstance { bool GetDownloadID(const int callback_id, int& download_id); + static common::PlatformResult convertError(int err); static void OnStateChanged (int download_id, download_state_e state, void* user_data); static void progress_changed_cb @@ -98,14 +98,15 @@ class DownloadInstance : public common::ParsedInstance { download_state_e state; }; - typedef std::map DownloadCallbackMap; + typedef DownloadCallback* CallbackPtr; + typedef std::map DownloadCallbackMap; typedef std::shared_ptr DownloadInfoPtr; typedef std::map DownloadInfoMap; static std::mutex instances_mutex_; static std::vector instances_; - DownloadCallbackMap downCbMap; + DownloadCallbackMap download_callbacks; DownloadInfoMap diMap; }; -- 2.34.1