From: Lukasz Bardeli <l.bardeli@samsung.com>
Date: Fri, 26 Jan 2018 09:37:21 +0000 (+0100)
Subject: [Download] refactoring module
X-Git-Tag: submit/tizen_4.0/20180126.102411~1
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=0f376b82154b662dbb3a43f82251c22a2af4c210;p=platform%2Fcore%2Fapi%2Fwebapi-plugins.git

[Download] refactoring module

Remove setMessageListener from download_api.js and start using from utils_api.js
Remove method declarations from .cc file getDownloadRequest and setListener
Variable name changes
Delete element from callbacks after finished, cancel or failed download

[Verification] Code compiles without error. TCT passrate 100%

Change-Id: Idcca394f4ec6bda7ea3097248a9c900b2a542f7a
Signed-off-by: Lukasz Bardeli <l.bardeli@samsung.com>
---

diff --git a/src/download/download_api.js b/src/download/download_api.js
index 331fcdc3..c689ed2c 100755
--- a/src/download/download_api.js
+++ b/src/download/download_api.js
@@ -14,27 +14,23 @@
  *    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() {
@@ -42,67 +38,35 @@ extension.setMessageListener(function(json) {
       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) {
@@ -211,25 +175,25 @@ DownloadManager.prototype.start = function() {
     '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() {
@@ -245,10 +209,10 @@ 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);
   }
 };
 
@@ -265,10 +229,10 @@ DownloadManager.prototype.pause = function() {
     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);
   }
 };
 
@@ -285,10 +249,10 @@ DownloadManager.prototype.resume = function() {
     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);
   }
 };
 
@@ -305,10 +269,12 @@ DownloadManager.prototype.getState = function() {
     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);
   }
 };
 
@@ -337,10 +303,12 @@ DownloadManager.prototype.getMIMEType = function() {
     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);
   }
 };
 
@@ -351,10 +319,10 @@ DownloadManager.prototype.setListener = function() {
       '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
diff --git a/src/download/download_instance.cc b/src/download/download_instance.cc
index 0572376b..4662cbf8 100644
--- a/src/download/download_instance.cc
+++ b/src/download/download_instance.cc
@@ -36,6 +36,7 @@ std::mutex DownloadInstance::instances_mutex_;
 namespace {
 // The privileges that required in Download API
 const std::string kPrivilegeDownload = "http://tizen.org/privilege/download";
+const std::string kDownloadManagerListenerId = "DownloadManagerListener";
 
 }  // namespace
 
@@ -45,8 +46,6 @@ DownloadInstance::DownloadInstance() {
   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);
@@ -66,27 +65,27 @@ DownloadInstance::~DownloadInstance() {
 
   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);
@@ -187,20 +186,20 @@ common::PlatformResult DownloadInstance::convertError(int err, const std::string
 
 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:
@@ -209,16 +208,16 @@ void DownloadInstance::OnStateChanged(int download_id, download_state_e state, v
       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);
@@ -228,29 +227,30 @@ void DownloadInstance::OnStateChanged(int download_id, download_state_e state, v
 
 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;
 }
@@ -259,72 +259,73 @@ void DownloadInstance::OnStart(int download_id, void* user_data) {
   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);
 
@@ -333,67 +334,69 @@ gboolean DownloadInstance::OnFinished(void* user_data) {
 
 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;
 }
@@ -403,25 +406,25 @@ gboolean DownloadInstance::OnFailed(void* user_data) {
   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");
@@ -433,25 +436,26 @@ gboolean DownloadInstance::OnFailed(void* user_data) {
                       ("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;
 }
@@ -459,38 +463,38 @@ gboolean DownloadInstance::OnFailed(void* user_data) {
 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>();
     }
   }
 
@@ -536,15 +540,15 @@ void DownloadInstance::DownloadManagerStart(const picojson::value& args, picojso
   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,
@@ -572,45 +576,45 @@ void DownloadInstance::DownloadManagerStart(const picojson::value& args, picojso
     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)));
@@ -618,8 +622,8 @@ void DownloadInstance::DownloadManagerStart(const picojson::value& args, picojso
     }
   }
 
-  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)));
@@ -627,19 +631,19 @@ void DownloadInstance::DownloadManagerStart(const picojson::value& args, picojso
     }
   }
 
-  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);
@@ -806,28 +810,16 @@ void DownloadInstance::DownloadManagerGetmimetype(const picojson::value& args,
   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
diff --git a/src/download/download_instance.h b/src/download/download_instance.h
index f628736e..4993b0db 100644
--- a/src/download/download_instance.h
+++ b/src/download/download_instance.h
@@ -50,11 +50,9 @@ class DownloadInstance : public common::ParsedInstance {
   void DownloadManagerPause(const picojson::value& args, picojson::object& out);
   void DownloadManagerResume(const picojson::value& args, picojson::object& out);
   void DownloadManagerGetstate(const picojson::value& args, picojson::object& out);
-  void DownloadManagerGetdownloadrequest(const picojson::value& args, picojson::object& out);
   void DownloadManagerGetmimetype(const picojson::value& args, picojson::object& out);
-  void DownloadManagerSetlistener(const picojson::value& args, picojson::object& out);
 
-  bool GetDownloadID(const int callback_id, int& download_id);
+  bool GetDownloadID(const int download_id, int& native_download_id);
 
   static common::PlatformResult convertError(int err, const std::string& message = "");
   static void OnStateChanged(int download_id, download_state_e state, void* user_data);
@@ -69,20 +67,20 @@ class DownloadInstance : public common::ParsedInstance {
   static bool CheckInstance(DownloadInstance* instance);
 
   struct DownloadInfo {
-    int callbackId;
+    int download_id;
     std::string url;
     std::string destination;
     std::string file_name;
     std::string http_header;
     download_network_type_e network_type;
 
-    int download_id;
+    int native_download_id;
     long long unsigned file_size;
   };
 
   struct DownloadCallback {
-    int callbackId;
-    int downloadId;
+    int download_id;
+    int native_download_id;
     DownloadInstance* instance;
     unsigned long long received;
     download_state_e state;
@@ -97,7 +95,7 @@ class DownloadInstance : public common::ParsedInstance {
   static std::vector<DownloadInstance*> instances_;
 
   DownloadCallbackMap download_callbacks;
-  DownloadInfoMap diMap;
+  DownloadInfoMap di_map;
 };
 
 }  // namespace download