| 
				
			 | 
			
			
				@@ -5,6 +5,7 @@ import { 
			 | 
		
	
		
			
			| 
				5
			 | 
			
				5
			 | 
			
			
				   NativeModules, 
			 | 
		
	
		
			
			| 
				6
			 | 
			
				6
			 | 
			
			
				   PermissionsAndroid, 
			 | 
		
	
		
			
			| 
				7
			 | 
			
				7
			 | 
			
			
				   Platform, 
			 | 
		
	
		
			
			| 
				
			 | 
			
				8
			 | 
			
			
				+  // $FlowFixMe 
			 | 
		
	
		
			
			| 
				8
			 | 
			
				9
			 | 
			
			
				 } from "react-native"; 
			 | 
		
	
		
			
			| 
				9
			 | 
			
				10
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				10
			 | 
			
				11
			 | 
			
			
				 const { RNPermissions } = NativeModules; 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -68,10 +69,10 @@ export type NotificationOption = 
			 | 
		
	
		
			
			| 
				68
			 | 
			
				69
			 | 
			
			
				   | "criticalAlert" 
			 | 
		
	
		
			
			| 
				69
			 | 
			
				70
			 | 
			
			
				   | "provisional"; 
			 | 
		
	
		
			
			| 
				70
			 | 
			
				71
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				71
			 | 
			
				
			 | 
			
			
				-export type RequestConfig = {| 
			 | 
		
	
		
			
			| 
				
			 | 
			
				72
			 | 
			
			
				+export type RequestConfig = { 
			 | 
		
	
		
			
			| 
				72
			 | 
			
				73
			 | 
			
			
				   notificationOptions?: NotificationOption[], 
			 | 
		
	
		
			
			| 
				73
			 | 
			
				74
			 | 
			
			
				   rationale?: Rationale, 
			 | 
		
	
		
			
			| 
				74
			 | 
			
				
			 | 
			
			
				-|}; 
			 | 
		
	
		
			
			| 
				
			 | 
			
				75
			 | 
			
			
				+}; 
			 | 
		
	
		
			
			| 
				75
			 | 
			
				76
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				76
			 | 
			
				77
			 | 
			
			
				 const platformPermissions = Object.values( 
			 | 
		
	
		
			
			| 
				77
			 | 
			
				78
			 | 
			
			
				   Platform.OS === "ios" ? IOS_PERMISSIONS : ANDROID_PERMISSIONS, 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -91,12 +92,12 @@ function assertValidPermission(permission: string) { 
			 | 
		
	
		
			
			| 
				91
			 | 
			
				92
			 | 
			
			
				 function getUnavailablePermissions(permissions: string[]) { 
			 | 
		
	
		
			
			| 
				92
			 | 
			
				93
			 | 
			
			
				   return Promise.all( 
			 | 
		
	
		
			
			| 
				93
			 | 
			
				94
			 | 
			
			
				     permissions.map(p => RNPermissions.isPermissionAvailable(p)), 
			 | 
		
	
		
			
			| 
				94
			 | 
			
				
			 | 
			
			
				-  ).then(result => 
			 | 
		
	
		
			
			| 
				95
			 | 
			
				
			 | 
			
			
				-    result.reduce( 
			 | 
		
	
		
			
			| 
				96
			 | 
			
				
			 | 
			
			
				-      (acc, isAvailable, i) => 
			 | 
		
	
		
			
			| 
				97
			 | 
			
				
			 | 
			
			
				-        isAvailable ? acc : { ...acc, [permissions[i]]: RESULTS.UNAVAILABLE }, 
			 | 
		
	
		
			
			| 
				98
			 | 
			
				
			 | 
			
			
				-      {}, 
			 | 
		
	
		
			
			| 
				99
			 | 
			
				
			 | 
			
			
				-    ), 
			 | 
		
	
		
			
			| 
				
			 | 
			
				95
			 | 
			
			
				+  ).then(availabilities => 
			 | 
		
	
		
			
			| 
				
			 | 
			
				96
			 | 
			
			
				+    availabilities.reduce((acc, available, i) => { 
			 | 
		
	
		
			
			| 
				
			 | 
			
				97
			 | 
			
			
				+      return !available 
			 | 
		
	
		
			
			| 
				
			 | 
			
				98
			 | 
			
			
				+        ? { ...acc, [permissions[i]]: RESULTS.UNAVAILABLE } 
			 | 
		
	
		
			
			| 
				
			 | 
			
				99
			 | 
			
			
				+        : acc; 
			 | 
		
	
		
			
			| 
				
			 | 
			
				100
			 | 
			
			
				+    }, {}), 
			 | 
		
	
		
			
			| 
				100
			 | 
			
				101
			 | 
			
			
				   ); 
			 | 
		
	
		
			
			| 
				101
			 | 
			
				102
			 | 
			
			
				 } 
			 | 
		
	
		
			
			| 
				102
			 | 
			
				103
			 | 
			
			
				  
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -104,14 +105,12 @@ const requestedKey = "@RNPermissions:requested"; 
			 | 
		
	
		
			
			| 
				104
			 | 
			
				105
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				105
			 | 
			
				106
			 | 
			
			
				 async function getRequestedPermissions() { 
			 | 
		
	
		
			
			| 
				106
			 | 
			
				107
			 | 
			
			
				   const requested = await AsyncStorage.getItem(requestedKey); 
			 | 
		
	
		
			
			| 
				107
			 | 
			
				
			 | 
			
			
				- 
			 | 
		
	
		
			
			| 
				108
			 | 
			
				108
			 | 
			
			
				   return requested ? JSON.parse(requested) : []; 
			 | 
		
	
		
			
			| 
				109
			 | 
			
				109
			 | 
			
			
				 } 
			 | 
		
	
		
			
			| 
				110
			 | 
			
				110
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				111
			 | 
			
				111
			 | 
			
			
				 async function setRequestedPermissions(permissions: string[]) { 
			 | 
		
	
		
			
			| 
				112
			 | 
			
				112
			 | 
			
			
				   const requested = await getRequestedPermissions(); 
			 | 
		
	
		
			
			| 
				113
			 | 
			
				113
			 | 
			
			
				   const dedup = [...new Set([...requested, ...permissions])]; 
			 | 
		
	
		
			
			| 
				114
			 | 
			
				
			 | 
			
			
				- 
			 | 
		
	
		
			
			| 
				115
			 | 
			
				114
			 | 
			
			
				   return AsyncStorage.setItem(requestedKey, dedup); 
			 | 
		
	
		
			
			| 
				116
			 | 
			
				115
			 | 
			
			
				 } 
			 | 
		
	
		
			
			| 
				117
			 | 
			
				116
			 | 
			
			
				  
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -141,22 +140,20 @@ async function internalCheck( 
			 | 
		
	
		
			
			| 
				141
			 | 
			
				140
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				142
			 | 
			
				141
			 | 
			
			
				 async function internalRequest( 
			 | 
		
	
		
			
			| 
				143
			 | 
			
				142
			 | 
			
			
				   permission: string, 
			 | 
		
	
		
			
			| 
				144
			 | 
			
				
			 | 
			
			
				-  config: RequestConfig, 
			 | 
		
	
		
			
			| 
				
			 | 
			
				143
			 | 
			
			
				+  config: RequestConfig = {}, 
			 | 
		
	
		
			
			| 
				145
			 | 
			
				144
			 | 
			
			
				 ): Promise<PermissionStatus> { 
			 | 
		
	
		
			
			| 
				146
			 | 
			
				145
			 | 
			
			
				   const { notificationOptions, rationale } = config; 
			 | 
		
	
		
			
			| 
				147
			 | 
			
				146
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				148
			 | 
			
				147
			 | 
			
			
				   if (Platform.OS !== "android") { 
			 | 
		
	
		
			
			| 
				149
			 | 
			
				148
			 | 
			
			
				     return RNPermissions.request(permission, { notificationOptions }); 
			 | 
		
	
		
			
			| 
				150
			 | 
			
				149
			 | 
			
			
				   } 
			 | 
		
	
		
			
			| 
				
			 | 
			
				150
			 | 
			
			
				+ 
			 | 
		
	
		
			
			| 
				151
			 | 
			
				151
			 | 
			
			
				   if (!(await RNPermissions.isPermissionAvailable(permission))) { 
			 | 
		
	
		
			
			| 
				152
			 | 
			
				152
			 | 
			
			
				     return RESULTS.UNAVAILABLE; 
			 | 
		
	
		
			
			| 
				153
			 | 
			
				153
			 | 
			
			
				   } 
			 | 
		
	
		
			
			| 
				154
			 | 
			
				154
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				155
			 | 
			
				155
			 | 
			
			
				   const status = await PermissionsAndroid.request(permission, rationale); 
			 | 
		
	
		
			
			| 
				156
			 | 
			
				
			 | 
			
			
				- 
			 | 
		
	
		
			
			| 
				157
			 | 
			
				
			 | 
			
			
				-  // set permission as requested 
			 | 
		
	
		
			
			| 
				158
			 | 
			
				
			 | 
			
			
				-  await setRequestedPermissions([permission]); 
			 | 
		
	
		
			
			| 
				159
			 | 
			
				
			 | 
			
			
				-  return status; 
			 | 
		
	
		
			
			| 
				
			 | 
			
				156
			 | 
			
			
				+  return setRequestedPermissions([permission]).then(() => status); 
			 | 
		
	
		
			
			| 
				160
			 | 
			
				157
			 | 
			
			
				 } 
			 | 
		
	
		
			
			| 
				161
			 | 
			
				158
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				162
			 | 
			
				159
			 | 
			
			
				 async function internalCheckMultiple( 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -168,7 +165,9 @@ async function internalCheckMultiple( 
			 | 
		
	
		
			
			| 
				168
			 | 
			
				165
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				169
			 | 
			
				166
			 | 
			
			
				   return Promise.all(available.map(p => internalCheck(p))) 
			 | 
		
	
		
			
			| 
				170
			 | 
			
				167
			 | 
			
			
				     .then(statuses => 
			 | 
		
	
		
			
			| 
				171
			 | 
			
				
			 | 
			
			
				-      statuses.reduce((acc, s, i) => ({ ...acc, [available[i]]: s }), {}), 
			 | 
		
	
		
			
			| 
				
			 | 
			
				168
			 | 
			
			
				+      statuses.reduce((acc, status, i) => { 
			 | 
		
	
		
			
			| 
				
			 | 
			
				169
			 | 
			
			
				+        return { ...acc, [available[i]]: status }; 
			 | 
		
	
		
			
			| 
				
			 | 
			
				170
			 | 
			
			
				+      }, {}), 
			 | 
		
	
		
			
			| 
				172
			 | 
			
				171
			 | 
			
			
				     ) 
			 | 
		
	
		
			
			| 
				173
			 | 
			
				172
			 | 
			
			
				     .then(statuses => ({ ...result, ...statuses })); 
			 | 
		
	
		
			
			| 
				174
			 | 
			
				173
			 | 
			
			
				 } 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -181,8 +180,7 @@ async function internalRequestMultiple( 
			 | 
		
	
		
			
			| 
				181
			 | 
			
				180
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				182
			 | 
			
				181
			 | 
			
			
				     for (let i = 0; i < permissions.length; i++) { 
			 | 
		
	
		
			
			| 
				183
			 | 
			
				182
			 | 
			
			
				       const permission = permissions[i]; 
			 | 
		
	
		
			
			| 
				184
			 | 
			
				
			 | 
			
			
				-      // avoid checking them all at once 
			 | 
		
	
		
			
			| 
				185
			 | 
			
				
			 | 
			
			
				-      result[permission] = await internalRequest(permission); 
			 | 
		
	
		
			
			| 
				
			 | 
			
				183
			 | 
			
			
				+      result[permission] = await internalRequest(permission); // once at the time 
			 | 
		
	
		
			
			| 
				186
			 | 
			
				184
			 | 
			
			
				     } 
			 | 
		
	
		
			
			| 
				187
			 | 
			
				185
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				188
			 | 
			
				186
			 | 
			
			
				     return result; 
			 | 
		
	
	
		
			
			| 
				
			 | 
			
			
				@@ -195,9 +193,7 @@ async function internalRequestMultiple( 
			 | 
		
	
		
			
			| 
				195
			 | 
			
				193
			 | 
			
			
				     permissions.filter(p => !unavailable.includes(p)), 
			 | 
		
	
		
			
			| 
				196
			 | 
			
				194
			 | 
			
			
				   ).then(statuses => ({ ...result, ...statuses })); 
			 | 
		
	
		
			
			| 
				197
			 | 
			
				195
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				198
			 | 
			
				
			 | 
			
			
				-  // set permissions as requested 
			 | 
		
	
		
			
			| 
				199
			 | 
			
				
			 | 
			
			
				-  await setRequestedPermissions(permissions); 
			 | 
		
	
		
			
			| 
				200
			 | 
			
				
			 | 
			
			
				-  return status; 
			 | 
		
	
		
			
			| 
				
			 | 
			
				196
			 | 
			
			
				+  return setRequestedPermissions(permissions).then(() => statuses); 
			 | 
		
	
		
			
			| 
				201
			 | 
			
				197
			 | 
			
			
				 } 
			 | 
		
	
		
			
			| 
				202
			 | 
			
				198
			 | 
			
			
				  
			 | 
		
	
		
			
			| 
				203
			 | 
			
				199
			 | 
			
			
				 export function openSettings(): Promise<boolean> { 
			 |