1"use strict";
2
3Object.defineProperty(exports, "__esModule", {
4  value: true
5});
6exports.addBlockedPermissions = addBlockedPermissions;
7exports.addPermission = addPermission;
8exports.addPermissionToManifest = addPermissionToManifest;
9exports.ensurePermission = ensurePermission;
10exports.ensurePermissionNameFormat = ensurePermissionNameFormat;
11exports.ensurePermissions = ensurePermissions;
12exports.getAndroidPermissions = getAndroidPermissions;
13exports.getPermissions = getPermissions;
14exports.isPermissionAlreadyRequested = isPermissionAlreadyRequested;
15exports.removePermissions = removePermissions;
16exports.setAndroidPermissions = setAndroidPermissions;
17exports.withPermissions = exports.withInternalBlockedPermissions = exports.withBlockedPermissions = void 0;
18function _Manifest() {
19  const data = require("./Manifest");
20  _Manifest = function () {
21    return data;
22  };
23  return data;
24}
25function _androidPlugins() {
26  const data = require("../plugins/android-plugins");
27  _androidPlugins = function () {
28    return data;
29  };
30  return data;
31}
32const USES_PERMISSION = 'uses-permission';
33const withPermissions = (config, permissions) => {
34  if (Array.isArray(permissions)) {
35    permissions = permissions.filter(Boolean);
36    if (!config.android) config.android = {};
37    if (!config.android.permissions) config.android.permissions = [];
38    config.android.permissions = [
39    // @ts-ignore
40    ...new Set(config.android.permissions.concat(permissions))];
41  }
42  return (0, _androidPlugins().withAndroidManifest)(config, async config => {
43    config.modResults = await setAndroidPermissions(config, config.modResults);
44    return config;
45  });
46};
47
48/** Given a permission or list of permissions, block permissions in the final `AndroidManifest.xml` to ensure no installed library or plugin can add them. */
49exports.withPermissions = withPermissions;
50const withBlockedPermissions = (config, permissions) => {
51  var _config$android;
52  const resolvedPermissions = prefixAndroidPermissionsIfNecessary((Array.isArray(permissions) ? permissions : [permissions]).filter(Boolean));
53  if (config !== null && config !== void 0 && (_config$android = config.android) !== null && _config$android !== void 0 && _config$android.permissions && Array.isArray(config.android.permissions)) {
54    // Remove any static config permissions
55    config.android.permissions = prefixAndroidPermissionsIfNecessary(config.android.permissions).filter(permission => !resolvedPermissions.includes(permission));
56  }
57  return (0, _androidPlugins().withAndroidManifest)(config, async config => {
58    config.modResults = (0, _Manifest().ensureToolsAvailable)(config.modResults);
59    config.modResults = addBlockedPermissions(config.modResults, resolvedPermissions);
60    return config;
61  });
62};
63exports.withBlockedPermissions = withBlockedPermissions;
64const withInternalBlockedPermissions = config => {
65  var _config$android2, _config$android2$bloc;
66  // Only add permissions if the user defined the property and added some values
67  // this ensures we don't add the `tools:*` namespace extraneously.
68  if ((_config$android2 = config.android) !== null && _config$android2 !== void 0 && (_config$android2$bloc = _config$android2.blockedPermissions) !== null && _config$android2$bloc !== void 0 && _config$android2$bloc.length) {
69    return withBlockedPermissions(config, config.android.blockedPermissions);
70  }
71  return config;
72};
73exports.withInternalBlockedPermissions = withInternalBlockedPermissions;
74function addBlockedPermissions(androidManifest, permissions) {
75  if (!Array.isArray(androidManifest.manifest['uses-permission'])) {
76    androidManifest.manifest['uses-permission'] = [];
77  }
78  for (const permission of prefixAndroidPermissionsIfNecessary(permissions)) {
79    androidManifest.manifest['uses-permission'] = ensureBlockedPermission(androidManifest.manifest['uses-permission'], permission);
80  }
81  return androidManifest;
82}
83
84/**
85 * Filter any existing permissions matching the provided permission name, then add a
86 * restricted permission to overwrite any extra permissions that may be added in a
87 * third-party package's AndroidManifest.xml.
88 *
89 * @param manifestPermissions manifest `uses-permissions` array.
90 * @param permission `android:name` of the permission to restrict
91 * @returns
92 */
93function ensureBlockedPermission(manifestPermissions, permission) {
94  // Remove permission if it currently exists
95  manifestPermissions = manifestPermissions.filter(e => e.$['android:name'] !== permission);
96
97  // Add a permission with tools:node to overwrite any existing permission and ensure it's removed upon building.
98  manifestPermissions.push({
99    $: {
100      'android:name': permission,
101      'tools:node': 'remove'
102    }
103  });
104  return manifestPermissions;
105}
106function prefixAndroidPermissionsIfNecessary(permissions) {
107  return permissions.map(permission => {
108    if (!permission.includes('.')) {
109      return `android.permission.${permission}`;
110    }
111    return permission;
112  });
113}
114function getAndroidPermissions(config) {
115  var _config$android$permi, _config$android3;
116  return (_config$android$permi = (_config$android3 = config.android) === null || _config$android3 === void 0 ? void 0 : _config$android3.permissions) !== null && _config$android$permi !== void 0 ? _config$android$permi : [];
117}
118function setAndroidPermissions(config, androidManifest) {
119  var _androidManifest$mani;
120  const permissions = getAndroidPermissions(config);
121  const providedPermissions = prefixAndroidPermissionsIfNecessary(permissions);
122  const permissionsToAdd = [...providedPermissions];
123  if (!androidManifest.manifest.hasOwnProperty('uses-permission')) {
124    androidManifest.manifest['uses-permission'] = [];
125  }
126  // manifest.manifest['uses-permission'] = [];
127
128  const manifestPermissions = (_androidManifest$mani = androidManifest.manifest['uses-permission']) !== null && _androidManifest$mani !== void 0 ? _androidManifest$mani : [];
129  permissionsToAdd.forEach(permission => {
130    if (!isPermissionAlreadyRequested(permission, manifestPermissions)) {
131      addPermissionToManifest(permission, manifestPermissions);
132    }
133  });
134  return androidManifest;
135}
136function isPermissionAlreadyRequested(permission, manifestPermissions) {
137  return manifestPermissions.some(e => e.$['android:name'] === permission);
138}
139function addPermissionToManifest(permission, manifestPermissions) {
140  manifestPermissions.push({
141    $: {
142      'android:name': permission
143    }
144  });
145  return manifestPermissions;
146}
147function removePermissions(androidManifest, permissionNames) {
148  const targetNames = permissionNames ? permissionNames.map(ensurePermissionNameFormat) : null;
149  const permissions = androidManifest.manifest[USES_PERMISSION] || [];
150  const nextPermissions = [];
151  for (const attribute of permissions) {
152    if (targetNames) {
153      // @ts-ignore: name isn't part of the type
154      const value = attribute.$['android:name'] || attribute.$.name;
155      if (!targetNames.includes(value)) {
156        nextPermissions.push(attribute);
157      }
158    }
159  }
160  androidManifest.manifest[USES_PERMISSION] = nextPermissions;
161}
162function addPermission(androidManifest, permissionName) {
163  const usesPermissions = androidManifest.manifest[USES_PERMISSION] || [];
164  usesPermissions.push({
165    $: {
166      'android:name': permissionName
167    }
168  });
169  androidManifest.manifest[USES_PERMISSION] = usesPermissions;
170}
171function ensurePermissions(androidManifest, permissionNames) {
172  const permissions = getPermissions(androidManifest);
173  const results = {};
174  for (const permissionName of permissionNames) {
175    const targetName = ensurePermissionNameFormat(permissionName);
176    if (!permissions.includes(targetName)) {
177      addPermission(androidManifest, targetName);
178      results[permissionName] = true;
179    } else {
180      results[permissionName] = false;
181    }
182  }
183  return results;
184}
185function ensurePermission(androidManifest, permissionName) {
186  const permissions = getPermissions(androidManifest);
187  const targetName = ensurePermissionNameFormat(permissionName);
188  if (!permissions.includes(targetName)) {
189    addPermission(androidManifest, targetName);
190    return true;
191  }
192  return false;
193}
194function ensurePermissionNameFormat(permissionName) {
195  if (permissionName.includes('.')) {
196    const com = permissionName.split('.');
197    const name = com.pop();
198    return [...com, name.toUpperCase()].join('.');
199  } else {
200    // If shorthand form like `WRITE_CONTACTS` is provided, expand it to `android.permission.WRITE_CONTACTS`.
201    return ensurePermissionNameFormat(`android.permission.${permissionName}`);
202  }
203}
204function getPermissions(androidManifest) {
205  const usesPermissions = androidManifest.manifest[USES_PERMISSION] || [];
206  const permissions = usesPermissions.map(permissionObject => {
207    return permissionObject.$['android:name'] || permissionObject.$.name;
208  });
209  return permissions;
210}
211//# sourceMappingURL=Permissions.js.map