var callbackId = 0;
var callbacks = {};
+var infoEventListenerId = -1;
+
+function invokeListener(result) {
+ if (result.listener === 'infoEvent') {
+ var listener = callbacks[infoEventListenerId];
+ listener(result);
+ }
+}
extension.setMessageListener(function(json) {
var result = JSON.parse(json);
- var callback = callbacks[result['callbackId']];
- callback(result);
+
+ if (result.hasOwnProperty('listener')) {
+ invokeListener(result);
+ } else {
+ var callback = callbacks[result['callbackId']];
+ callback(result);
+ }
});
function nextCallbackId() {
}
}
-
function callNativeWithCallback(cmd, args, callback) {
if (callback) {
var id = nextCallbackId();
}
try {
- var resultObject = callNative('PackageManager_getPackageInfo', nativeParam);
- return PackageInformation(resultObject);
+ var syncResult = callNative('PackageManager_getPackageInfo', nativeParam);
+ return PackageInformation(syncResult);
} catch (e) {
throw e;
}
function(result) {
if (result.status == 'installed') {
args.eventCallback.oninstalled(PackageInformation(result.info));
- }
- if (result.status == 'updated') {
+ } else if (result.status == 'updated') {
args.eventCallback.onupdated(PackageInformation(result.info));
- }
- if (result.status == 'uninstalled') {
+ } else if (result.status == 'uninstalled') {
args.eventCallback.onuninstalled(result.id);
}
});
+
+ if (infoEventListenerId === -1) {
+ infoEventListenerId = nativeParam.callbackId;
+ } else {
+ delete callbacks[infoEventListenerId];
+ infoEventListenerId = nativeParam.callbackId;
+ }
+
} catch (e) {
throw e;
}
try {
var syncResult = callNative('PackageManager_unsetPackageInfoEventListener', nativeParam);
- if (typeof syncResult != 'boolean') {
- delete callbacks[syncResult];
+ if (syncResult === true) {
+ delete callbacks[infoEventListenerId];
+ infoEventListenerId = -1;
}
} catch (e) {
throw e;
}
picojson::object object_info;
- if ( PackageInfoProvider::GetPackageInfo(info, object_info) ) {
+ if ( PackageInfoProvider::ConvertToPackageToObject(
+ info, object_info) ) {
array_data->push_back(picojson::value(object_info));
}
}
picojson::object object_info;
- if ( !GetPackageInfo(info, object_info) ) {
+ if ( !ConvertToPackageToObject(info, object_info) ) {
LoggerE("Failed to convert pkginfo to object");
REPORT_ERROR(out, UnknownException(
"The package information cannot be retrieved " \
return true;
}
-bool PackageInfoProvider:: GetPackageInfo(
+bool PackageInfoProvider:: ConvertToPackageToObject(
const pkgmgrinfo_pkginfo_h info, picojson::object& out) {
int ret = 0;
static void GetPackageInfo(picojson::object& out);
static void GetPackageInfo(const char* package_id,
picojson::object& out);
- static bool GetPackageInfo(const pkgmgrinfo_pkginfo_h info,
- picojson::object& out);
+
+ static bool ConvertToPackageToObject(
+ const pkgmgrinfo_pkginfo_h info, picojson::object& out);
private:
static bool GetCurrentPackageId(char** package_id);
}
picojson::object param;
+ param["listener"] = picojson::value("infoEvent");
+
if ( event_type == PACKAGE_MANAGER_EVENT_TYPE_INSTALL
&& event_state == PACKAGE_MANAGER_EVENT_STATE_COMPLETED ) {
LoggerD("[Installed]");
manager_ = NULL;
}
- listener_id_ = -1;
+ is_package_info_listener_set_ = false;
using std::placeholders::_1;
using std::placeholders::_2;
void PackageInstance::InvokeListener(picojson::object& param) {
LoggerD("Enter");
-
- param["callbackId"] = picojson::value(static_cast<double>(listener_id_));
picojson::value result = picojson::value(param);
PostMessage(result.serialize().c_str());
}
return;
*/
+ if ( is_package_info_listener_set_ ) {
+ LoggerD("Already set");
+ ReportSuccess(out);
+ return;
+ }
+
if ( !manager_ ) {
LoggerE("package_manager_h is NULL");
ReportError(
return;
}
- listener_id_ = callback_id;
+ is_package_info_listener_set_ = true;
ReportSuccess(out);
}
return;
*/
- if ( listener_id_ == -1 ) {
+ if ( !is_package_info_listener_set_ ) {
LoggerD("Listener is not set");
ReportSuccess(out);
return;
return;
}
- ReportSuccess(picojson::value(static_cast<double>(listener_id_)), out);
- listener_id_ = -1;
+ is_package_info_listener_set_ = false;
+ ReportSuccess(out);
}
void PackageInstance::InvokeErrorCallbackAsync(
private:
package_manager_request_h request_;
package_manager_h manager_;
- int listener_id_;
+ bool is_package_info_listener_set_;
std::map<int, int> callbacks_map_; // <request_id, callbackId>
void RegisterCallback(int request_id, int callback_id);