[PPM] Add checkPermissions and requestPermissions implementation

Added two new methods to ProvacyPrivilegeManager

[Verification] Code compiles without error. Tested in console

var p = ["http://tizen.org/privilege/filesystem.read", "http://tizen.org/privilege/alarm"];

var a = tizen.ppm.checkPermissions(p);

for(v in a){
  alert(a[v].privilege+" - "+ a[v].type);
}

function permissionSuccess(result)
{
  for(v in result){
    alert(result[v].privilege+" - "+ result[v].result);
  }
}

var p = ["http://tizen.org/privilege/contact.read", "http://tizen.org/privilege/contact.write"];

tizen.ppm.requestPermissions(p, permissionSuccess);

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

diff --git a/src/ppm/ppm_api.js b/src/ppm/ppm_api.js
index 6bc52a06e8d45edeb9c64b507cb2e4ee734ac0b6..3193a7dfcfea3dcce44d6697465b9c64ddf3931b 100644 (file)
--- a/src/ppm/ppm_api.js
+++ b/src/ppm/ppm_api.js
@@ -23,6 +23,13 @@ var native_ = new xwalk.utils.NativeManager(extension);
 function PPMManager() {
 }
 
+function RequestStatus(privilege, result_) {
+    Object.defineProperties(this, {
+        privilege : {value: privilege, writable: false},
+        result : {value: result_, writable: false}
+    });
+};
+
 PPMManager.prototype.checkPermission = function() {
   var args = validator_.validateArgs(arguments, [
       { name: 'privilege', type: types_.STRING }
@@ -41,6 +48,32 @@ PPMManager.prototype.checkPermission = function() {
   return native_.getResultObject(result);
 };
 
+PPMManager.prototype.checkPermissions = function() {
+  var args = validator_.validateArgs(arguments, [
+      { name: 'privileges', type: types_.ARRAY, values: types_.STRING }
+  ]);
+
+  var callArgs = {
+      privileges: args.privileges
+  };
+
+  var result = native_.callSync('PPMManager_checkPermissions', callArgs);
+
+  var data = [];
+
+  if (native_.isFailure(result)) {
+    throw native_.getErrorObject(result);
+  } else {
+    var obj = native_.getResultObject(result);
+
+    obj.forEach(function (o) {
+      data.push({'privilege':o.privilege, 'type':o.type});
+    });
+  }
+
+  return data;
+};
+
 PPMManager.prototype.requestPermission = function() {
     var args = validator_.validateArgs(arguments, [
         { name: 'privilege', type: types_.STRING },
@@ -67,5 +100,37 @@ PPMManager.prototype.requestPermission = function() {
     }
 };
 
+PPMManager.prototype.requestPermissions = function() {
+  var args = validator_.validateArgs(arguments, [
+      { name: 'privileges', type: types_.ARRAY, values: types_.STRING },
+      { name: 'successCallback', type: types_.FUNCTION },
+      { name: 'errorCallback', type: types_.FUNCTION, optional: true, nullable: true }
+  ]);
+
+  var callback = function(result) {
+      if (native_.isFailure(result)) {
+        native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
+      } else {
+        var data = [];
+        var obj = native_.getResultObject(result);
+
+        obj.forEach(function (o) {
+          data.push(new RequestStatus(o.privilege, o.result));
+        });
+        args.successCallback(data);
+      }
+  };
+
+  var callArgs = {
+      privileges: args.privileges
+  };
+
+  var result = native_.call('PPMManager_requestPermissions', callArgs, callback);
+
+  if (native_.isFailure(result)) {
+    throw native_.getErrorObject(result);
+  }
+};
+
 // Exports
 exports = new PPMManager();
\ No newline at end of file

diff --git a/src/ppm/ppm_instance.cc b/src/ppm/ppm_instance.cc
index 7f419a320e5ec0a3dd70dd7490f6d517f8c9d617..5e3c7515a374f748a6e1e5c53d91a2122887e127 100644 (file)
--- a/src/ppm/ppm_instance.cc
+++ b/src/ppm/ppm_instance.cc
@@ -46,7 +46,9 @@ PPMInstance::PPMInstance() {
 #define REGISTER(c, x) RegisterSyncHandler(c, std::bind(&PPMInstance::x, this, _1, _2));
 
   REGISTER("PPMManager_checkPermission", checkPermission);
+  REGISTER("PPMManager_checkPermissions", checkPermissions);
   REGISTER("PPMManager_requestPermission", requestPermission);
+  REGISTER("PPMManager_requestPermissions", requestPermissions);
 
 #undef REGISTER
 }
@@ -127,6 +129,37 @@ void PPMInstance::ResponseCallback(ppm_call_cause_e cause, ppm_request_result_e
   common::Instance::PostMessage(data->_instance, event.serialize().c_str());
 }
 
+void PPMInstance::ResponseMultipleCallback(ppm_call_cause_e cause, const ppm_request_result_e *result,
+                                   const char** privileges, size_t privileges_count, void* user_data) {
+  ScopeLogger();
+
+  std::unique_ptr<ResponseCallbackData> data{static_cast<ResponseCallbackData*>(user_data)};
+
+  picojson::value event = picojson::value(picojson::object());
+  picojson::object& obj = event.get<picojson::object>();
+
+  obj.insert(std::make_pair("callbackId", picojson::value(data->callbackId)));
+
+  if (PRIVACY_PRIVILEGE_MANAGER_CALL_CAUSE_ANSWER == cause) {
+    picojson::value result_array = picojson::value(picojson::array());
+    picojson::array& array_obj = result_array.get<picojson::array>();
+
+    for (size_t i = 0; i < privileges_count; i++) {
+      picojson::value result_elem = picojson::value(picojson::object());
+      picojson::object& obj = result_elem.get<picojson::object>();
+      obj["privilege"] = picojson::value(privileges[i]);
+      obj["result"] = picojson::value(CheckRequestResultToString(result[i]));
+      array_obj.push_back(result_elem);
+    }
+    obj.insert(std::make_pair("result", result_array));
+  } else {
+    LogAndReportError(
+        common::PlatformResult(common::ErrorCode::ABORT_ERR, "Get callback data failed"), &obj);
+  }
+
+  common::Instance::PostMessage(data->_instance, event.serialize().c_str());
+}
+
 void PPMInstance::checkPermission(const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   const std::string& privilege = args.get("privilege").get<std::string>();
@@ -145,6 +178,45 @@ void PPMInstance::checkPermission(const picojson::value& args, picojson::object&
   ReportSuccess(picojson::value(CheckResultToString(result)), out);
 }
 
+void PPMInstance::checkPermissions(const picojson::value& args, picojson::object& out) {
+  ScopeLogger();
+
+  const picojson::array& privileges = args.get("privileges").get<picojson::array>();
+  unsigned int size = static_cast<int>(privileges.size());
+
+  std::vector<const char*> privilege_array;
+  size_t i = 0;
+
+  for (auto iter = privileges.begin(); iter != privileges.end(); ++iter, ++i) {
+    privilege_array.push_back(iter->get<std::string>().c_str());
+  }
+
+  std::vector<ppm_check_result_e> results(size);
+  int ret = ppm_check_permissions(privilege_array.data(), size, results.data());
+
+  if (PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE != ret) {
+    LogAndReportError(convertError(ret), &out,
+                      ("checkPermission error: %d (%s)", ret, get_error_message(ret)));
+
+    return;
+  }
+
+  picojson::value result_array = picojson::value(picojson::array());
+  picojson::array& array_obj = result_array.get<picojson::array>();
+
+  for (size_t i = 0; i < size; i++) {
+    picojson::value result_elem = picojson::value(picojson::object());
+    picojson::object& obj = result_elem.get<picojson::object>();
+
+    obj["privilege"] = picojson::value(privilege_array[i]);
+    obj["type"] = picojson::value(CheckResultToString(results[i]));
+
+    array_obj.push_back(result_elem);
+  }
+
+  ReportSuccess(result_array, out);
+}
+
 void PPMInstance::requestPermission(const picojson::value& args, picojson::object& out) {
   ScopeLogger();
 
@@ -169,5 +241,36 @@ void PPMInstance::requestPermission(const picojson::value& args, picojson::objec
   ReportSuccess(out);
 }
 
+void PPMInstance::requestPermissions(const picojson::value& args, picojson::object& out) {
+  ScopeLogger();
+
+  const double callback_id = args.get("callbackId").get<double>();
+
+  const picojson::array& privileges = args.get("privileges").get<picojson::array>();
+  unsigned int size = static_cast<int>(privileges.size());
+
+  std::vector<const char*> privilege_array;
+  size_t i = 0;
+
+  for (auto iter = privileges.begin(); iter != privileges.end(); ++iter, ++i) {
+    privilege_array.push_back(iter->get<std::string>().c_str());
+  }
+
+  ResponseCallbackData* user_data{new ResponseCallbackData()};
+  user_data->_instance = this;
+  user_data->callbackId = callback_id;
+
+  int ret =
+      ppm_request_permissions(privilege_array.data(), size, ResponseMultipleCallback, static_cast<void*>(user_data));
+
+  if (PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE != ret) {
+    LogAndReportError(convertError(ret), &out,
+                      ("checkPermission error: %d (%s)", ret, get_error_message(ret)));
+    return;
+  }
+
+  ReportSuccess(out);
+}
+
 }  // namespace ppm
 }  // namespace extension

diff --git a/src/ppm/ppm_instance.h b/src/ppm/ppm_instance.h
index 9d1825ce641ab648980f187e06e3cc907593a170..3a2103ff13b81bebe2db21c0c4798d92c537625f 100644 (file)
--- a/src/ppm/ppm_instance.h
+++ b/src/ppm/ppm_instance.h
@@ -34,14 +34,19 @@ class PPMInstance : public common::ParsedInstance {
   virtual ~PPMInstance();
 
  private:
-  void checkPermission(const picojson::value& args, picojson::object& out);
+  void checkPermission(const picojson::value& args, picojson::object& out);\
+  void checkPermissions(const picojson::value& args, picojson::object& out);
   void requestPermission(const picojson::value& args, picojson::object& out);
+  void requestPermissions(const picojson::value& args, picojson::object& out);
 
   static common::PlatformResult convertError(int err, const std::string& message = "");
   static std::string CheckResultToString(ppm_check_result_e result);
   static std::string CheckRequestResultToString(ppm_request_result_e result);
   static void ResponseCallback(ppm_call_cause_e cause, ppm_request_result_e result,
                                const char* privilege, void* user_data);
+  static void ResponseMultipleCallback(ppm_call_cause_e cause, const ppm_request_result_e* result,
+                               const char** privileges, size_t privileges_count,
+                               void* user_data);
 };
 
 }  // namespace ppm