src/keymanager/keymanager_api.js

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 var validator = xwalk.utils.validator;
  18 var converter = xwalk.utils.converter;
  19 var type = xwalk.utils.type;
  20 var native = new xwalk.utils.NativeManager(extension);
  21
  22 var PermissionType = {
  23   "NONE" : "NONE",
  24   "READ": "READ",
  25   "REMOVE" : "REMOVE",
  26   "READ_REMOVE": "READ_REMOVE"
  27 };
  28
  29 function KeyManager() {
  30
  31 }
  32
  33 KeyManager.prototype.saveData = function() {
  34     var args = validator.validateArgs(arguments, [
  35       {
  36         name: 'aliasName',
  37         type: validator.Types.STRING
  38       },
  39       {
  40         name: 'rawData',
  41         type: validator.Types.STRING
  42       },
  43       {
  44         name: "password",
  45         type: validator.Types.STRING,
  46         optional: true,
  47         nullable: true
  48       },
  49       {
  50         name: 'successCallback',
  51         type: validator.Types.FUNCTION,
  52         optional: true,
  53         nullable: true
  54       },
  55       {
  56         name: 'errorCallback',
  57         type: validator.Types.FUNCTION,
  58         optional: true,
  59         nullable: true
  60       }
  61     ]);
  62
  63     var result = native.call('KeyManager_saveData', {
  64       aliasName: _trim(args.aliasName),
  65       rawData: args.rawData,
  66       password: (args.password ? converter.toString(args.password) : null)
  67     }, function(msg) {
  68         if (native.isFailure(msg)) {
  69           native.callIfPossible(args.errorCallback, native.getErrorObject(msg));
  70         } else {
  71           native.callIfPossible(args.successCallback);
  72         }
  73       }
  74     );
  75
  76     if (native.isFailure(result)) {
  77       throw native.getErrorObject(result);
  78     }
  79   };
  80
  81 KeyManager.prototype.removeData = function() {
  82
  83   var args = validator.validateArgs(arguments, [
  84     {
  85       name : 'dataAlias',
  86       type : validator.Types.DICTIONARY
  87     }
  88   ]);
  89
  90   var data_alias = _trim(args.dataAlias.name);
  91   if(args.dataAlias.hasOwnProperty('packageId')) {
  92     data_alias = args.dataAlias.packageId + ' ' + data_alias;
  93   }
  94
  95   var ret = native.callSync('KeyManager_removeAlias', {
  96     aliasName: data_alias
  97   });
  98   if (native.isFailure(ret)) {
  99     throw native.getErrorObject(ret);
 100   }
 101 };
 102
 103 KeyManager.prototype.getData = function() {
 104   var args = validator.validateArgs(arguments, [
 105     {
 106       name: "dataAlias",
 107       type: validator.Types.DICTIONARY
 108     },
 109     {
 110       name: "password",
 111       type: validator.Types.STRING,
 112       optional: true,
 113       nullable: true
 114     }
 115   ]);
 116
 117   var data_alias = _trim(args.dataAlias.name);
 118   if(args.dataAlias.hasOwnProperty('packageId')) {
 119     data_alias = args.dataAlias.packageId + ' ' + data_alias;
 120   }
 121
 122   var ret = native.callSync('KeyManager_getData', {
 123     name: data_alias,
 124     password: args.password
 125   });
 126   if (native.isFailure(ret)) {
 127     throw native.getErrorObject(ret);
 128   }
 129   var result = native.getResultObject(ret);
 130   return result.rawData;
 131 };
 132
 133 KeyManager.prototype.getDataAliasList = function() {
 134   var ret = native.callSync('KeyManager_getDataAliasList', {});
 135   if (native.isFailure(ret)) {
 136     throw native.getErrorObject(ret);
 137   }
 138   return native.getResultObject(ret);
 139 };
 140
 141 KeyManager.prototype.setPermission = function() {
 142   var args = validator.validateArgs(arguments, [
 143     {
 144       name: "dataAlias",
 145       type: validator.Types.DICTIONARY
 146     },
 147     {
 148       name: "packageId",
 149       type: validator.Types.STRING
 150     },
 151     {
 152       name: 'permissionType',
 153       type: validator.Types.ENUM,
 154       values: Object.keys(PermissionType)
 155     },
 156     {
 157       name: 'successCallback',
 158       type: validator.Types.FUNCTION,
 159       optional: true,
 160       nullable: true
 161     },
 162     {
 163       name: 'errorCallback',
 164       type: validator.Types.FUNCTION,
 165       optional: true,
 166       nullable: true
 167     }
 168   ]);
 169
 170   var data_alias = _trim(args.dataAlias.name);
 171   if(args.dataAlias.hasOwnProperty('packageId')) {
 172     data_alias = args.dataAlias.packageId + ' ' + data_alias;
 173   }
 174
 175   var result = native.call('KeyManager_setPermissions', {
 176     aliasName: data_alias,
 177     packageId: args.packageId,
 178     permissionType: args.permissionType
 179   }, function(msg) {
 180     if (native.isFailure(msg)) {
 181       native.callIfPossible(args.errorCallback, native.getErrorObject(msg));
 182     } else {
 183       native.callIfPossible(args.successCallback);
 184     }
 185   });
 186
 187   if (native.isFailure(result)) {
 188     throw native.getErrorObject(result);
 189   }
 190 };
 191
 192 function _trim(str){
 193   var val = str;
 194   if (!type.isString(str)) {
 195     val = converter.toString(str);
 196   }
 197
 198   return val.replace(/\s/gi, '');
 199 }
 200
 201 exports = new KeyManager();