expo-tracking-transparency 1.1.2 → 2.0.3

package/CHANGELOG.md

@@ -10,14 +10,36 @@
 
 ### 💡 Others
 
-## 1.1.2 — 2021-06-24
+## 2.0.3 — 2021-10-21
 
 _This version does not introduce any user-facing changes._
 
-## 1.1.1 — 2021-06-22
+## 2.0.2 — 2021-10-15
 
 _This version does not introduce any user-facing changes._
 
+## 2.0.1 — 2021-10-01
+
+_This version does not introduce any user-facing changes._
+
+## 2.0.0 — 2021-09-28
+
+### 🛠 Breaking changes
+
+- Dropped support for iOS 11.0 ([#14383](https://github.com/expo/expo/pull/14383) by [@cruzach](https://github.com/cruzach))
+
+### 🎉 New features
+
+- Add `useTrackingPermissions` hook from modules factory. ([#13864](https://github.com/expo/expo/pull/13864) by [@bycedric](https://github.com/bycedric))
+
+### 🐛 Bug fixes
+
+- Fix building errors from use_frameworks! in Podfile. ([#14523](https://github.com/expo/expo/pull/14523) by [@kudo](https://github.com/kudo))
+
+### 💡 Others
+
+- Updated `@expo/config-plugins` ([#14443](https://github.com/expo/expo/pull/14443) by [@EvanBacon](https://github.com/EvanBacon))
+
 ## 1.1.0 — 2021-06-16
 
 ### 💡 Others

package/build/ExpoTrackingTransparency.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("@unimodules/core").ProxyNativeModule;
+declare const _default: import("expo-modules-core").ProxyNativeModule;
 export default _default;

package/build/ExpoTrackingTransparency.js

@@ -1,3 +1,3 @@
-import { NativeModulesProxy } from '@unimodules/core';
+import { NativeModulesProxy } from 'expo-modules-core';
 export default NativeModulesProxy.ExpoTrackingTransparency;
 //# sourceMappingURL=ExpoTrackingTransparency.js.map

package/build/ExpoTrackingTransparency.js.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoTrackingTransparency.js","sourceRoot":"","sources":["../src/ExpoTrackingTransparency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,eAAe,kBAAkB,CAAC,wBAAwB,CAAC","sourcesContent":["import { NativeModulesProxy } from '@unimodules/core';\n\nexport default NativeModulesProxy.ExpoTrackingTransparency;\n"]}
+{"version":3,"file":"ExpoTrackingTransparency.js","sourceRoot":"","sources":["../src/ExpoTrackingTransparency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD,eAAe,kBAAkB,CAAC,wBAAwB,CAAC","sourcesContent":["import { NativeModulesProxy } from 'expo-modules-core';\n\nexport default NativeModulesProxy.ExpoTrackingTransparency;\n"]}

package/build/TrackingTransparency.d.ts

@@ -1,4 +1,4 @@
-import { PermissionResponse, PermissionStatus, PermissionExpiration } from 'expo-modules-core';
+import { PermissionResponse, PermissionStatus, PermissionExpiration, PermissionHookOptions } from 'expo-modules-core';
 /**
  * Requests the user to authorize or deny access to app-related data that can be used for tracking
  * the user or the device. Examples of data used for tracking include email address, device ID,
@@ -22,7 +22,7 @@ import { PermissionResponse, PermissionStatus, PermissionExpiration } from 'expo
 export declare function requestTrackingPermissionsAsync(): Promise<PermissionResponse>;
 /**
  * Checks whether or not the user has authorized the app to access app-related data that can be used
- * for tracking the user or the device. See `requestPermissionsAsync` for more details.
+ * for tracking the user or the device. See `requestTrackingPermissionsAsync` for more details.
  *
  * On Android, web, and iOS 13 and below, this method always returns that the permission was
  * granted.
@@ -37,6 +37,23 @@ export declare function requestTrackingPermissionsAsync(): Promise<PermissionRes
  * ```
  */
 export declare function getTrackingPermissionsAsync(): Promise<PermissionResponse>;
+/**
+ * Check or request the user to authorize or deny access to app-related data that can be used for tracking
+ * the user or the device. Examples of data used for tracking include email address, device ID,
+ * advertising ID, etc. On iOS 14.5 and above, if the user denies this permission, any attempt to
+ * collect the IDFA will return a string of 0s.
+ *
+ * The system remembers the user’s choice and doesn’t prompt again unless a user uninstalls and then
+ * reinstalls the app on the device.
+ *
+ * On Android, web, and iOS 13 and below, this method always returns that the permission was
+ * granted.
+ * @example
+ * ```ts
+ * const [status, requestPermission] = useTrackingPermissions();
+ * ```
+ */
+export declare const useTrackingPermissions: (options?: PermissionHookOptions<object> | undefined) => [PermissionResponse | null, () => Promise<PermissionResponse>, () => Promise<PermissionResponse>];
 /**
  * Returns whether the TrackingTransparency API is available on the current device.
  *
@@ -45,4 +62,4 @@ export declare function getTrackingPermissionsAsync(): Promise<PermissionRespons
  * resolve to `granted`.
  */
 export declare function isAvailable(): boolean;
-export { PermissionResponse, PermissionStatus, PermissionExpiration };
+export { PermissionResponse, PermissionStatus, PermissionExpiration, PermissionHookOptions };

package/build/TrackingTransparency.js

@@ -1,5 +1,4 @@
-import { UnavailabilityError } from '@unimodules/core';
-import { PermissionStatus } from 'expo-modules-core';
+import { PermissionStatus, UnavailabilityError, createPermissionHook, } from 'expo-modules-core';
 import { Platform } from 'react-native';
 import ExpoTrackingTransparency from './ExpoTrackingTransparency';
 const androidAndWebPermissionsResponse = {
@@ -39,7 +38,7 @@ export async function requestTrackingPermissionsAsync() {
 }
 /**
  * Checks whether or not the user has authorized the app to access app-related data that can be used
- * for tracking the user or the device. See `requestPermissionsAsync` for more details.
+ * for tracking the user or the device. See `requestTrackingPermissionsAsync` for more details.
  *
  * On Android, web, and iOS 13 and below, this method always returns that the permission was
  * granted.
@@ -62,6 +61,26 @@ export async function getTrackingPermissionsAsync() {
     }
     return await ExpoTrackingTransparency.getPermissionsAsync();
 }
+/**
+ * Check or request the user to authorize or deny access to app-related data that can be used for tracking
+ * the user or the device. Examples of data used for tracking include email address, device ID,
+ * advertising ID, etc. On iOS 14.5 and above, if the user denies this permission, any attempt to
+ * collect the IDFA will return a string of 0s.
+ *
+ * The system remembers the user’s choice and doesn’t prompt again unless a user uninstalls and then
+ * reinstalls the app on the device.
+ *
+ * On Android, web, and iOS 13 and below, this method always returns that the permission was
+ * granted.
+ * @example
+ * ```ts
+ * const [status, requestPermission] = useTrackingPermissions();
+ * ```
+ */
+export const useTrackingPermissions = createPermissionHook({
+    getMethod: getTrackingPermissionsAsync,
+    requestMethod: requestTrackingPermissionsAsync,
+});
 /**
  * Returns whether the TrackingTransparency API is available on the current device.
  *

package/build/TrackingTransparency.js.map

@@ -1 +1 @@
-{"version":3,"file":"TrackingTransparency.js","sourceRoot":"","sources":["../src/TrackingTransparency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAsB,gBAAgB,EAAwB,MAAM,mBAAmB,CAAC;AAC/F,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,OAAO,wBAAwB,MAAM,4BAA4B,CAAC;AAElE,MAAM,gCAAgC,GAAuB;IAC3D,OAAO,EAAE,IAAI;IACb,OAAO,EAAE,OAAO;IAChB,WAAW,EAAE,IAAI;IACjB,MAAM,EAAE,gBAAgB,CAAC,OAAO;CACjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,+BAA+B;IACnD,IAAI,QAAQ,CAAC,EAAE,KAAK,KAAK,EAAE;QACzB,OAAO,OAAO,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;KAC1D;IAED,IAAI,CAAC,wBAAwB,CAAC,uBAAuB,EAAE;QACrD,MAAM,IAAI,mBAAmB,CAAC,sBAAsB,EAAE,yBAAyB,CAAC,CAAC;KAClF;IACD,OAAO,MAAM,wBAAwB,CAAC,uBAAuB,EAAE,CAAC;AAClE,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B;IAC/C,IAAI,QAAQ,CAAC,EAAE,KAAK,KAAK,EAAE;QACzB,OAAO,OAAO,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;KAC1D;IAED,IAAI,CAAC,wBAAwB,CAAC,mBAAmB,EAAE;QACjD,MAAM,IAAI,mBAAmB,CAAC,sBAAsB,EAAE,qBAAqB,CAAC,CAAC;KAC9E;IACD,OAAO,MAAM,wBAAwB,CAAC,mBAAmB,EAAE,CAAC;AAC9D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW;IACzB,OAAO,CACL,QAAQ,CAAC,EAAE,KAAK,KAAK;QACrB,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE;QAC/C,wBAAwB,CACzB,CAAC;AACJ,CAAC;AAED,OAAO,EAAsB,gBAAgB,EAAwB,CAAC","sourcesContent":["import { UnavailabilityError } from '@unimodules/core';\nimport { PermissionResponse, PermissionStatus, PermissionExpiration } from 'expo-modules-core';\nimport { Platform } from 'react-native';\n\nimport ExpoTrackingTransparency from './ExpoTrackingTransparency';\n\nconst androidAndWebPermissionsResponse: PermissionResponse = {\n  granted: true,\n  expires: 'never',\n  canAskAgain: true,\n  status: PermissionStatus.GRANTED,\n};\n\n/**\n * Requests the user to authorize or deny access to app-related data that can be used for tracking\n * the user or the device. Examples of data used for tracking include email address, device ID,\n * advertising ID, etc. On iOS 14.5 and above, if the user denies this permission, any attempt to\n * collect the IDFA will return a string of 0s.\n *\n * The system remembers the user’s choice and doesn’t prompt again unless a user uninstalls and then\n * reinstalls the app on the device.\n *\n * On Android, web, and iOS 13 and below, this method always returns that the permission was\n * granted.\n * @example\n * ```typescript\n * const { granted } = await requestTrackingPermissionsAsync();\n *\n * if (granted) {\n *   // Your app is authorized to track the user or their device\n * }\n * ```\n */\nexport async function requestTrackingPermissionsAsync(): Promise<PermissionResponse> {\n  if (Platform.OS !== 'ios') {\n    return Promise.resolve(androidAndWebPermissionsResponse);\n  }\n\n  if (!ExpoTrackingTransparency.requestPermissionsAsync) {\n    throw new UnavailabilityError('TrackingTransparency', 'requestPermissionsAsync');\n  }\n  return await ExpoTrackingTransparency.requestPermissionsAsync();\n}\n\n/**\n * Checks whether or not the user has authorized the app to access app-related data that can be used\n * for tracking the user or the device. See `requestPermissionsAsync` for more details.\n *\n * On Android, web, and iOS 13 and below, this method always returns that the permission was\n * granted.\n *\n * @example\n * ```typescript\n * const { granted } = await getTrackingPermissionsAsync();\n *\n * if (granted) {\n *   // Your app is authorized to track the user or their device\n * }\n * ```\n */\nexport async function getTrackingPermissionsAsync(): Promise<PermissionResponse> {\n  if (Platform.OS !== 'ios') {\n    return Promise.resolve(androidAndWebPermissionsResponse);\n  }\n\n  if (!ExpoTrackingTransparency.getPermissionsAsync) {\n    throw new UnavailabilityError('TrackingTransparency', 'getPermissionsAsync');\n  }\n  return await ExpoTrackingTransparency.getPermissionsAsync();\n}\n\n/**\n * Returns whether the TrackingTransparency API is available on the current device.\n *\n * @returns Currently this is `true` on iOS 14 and above only. On devices where the\n * Tracking Transparency API is unavailable, the get and request permissions methods will always\n * resolve to `granted`.\n */\nexport function isAvailable(): boolean {\n  return (\n    Platform.OS === 'ios' &&\n    parseInt(Platform.Version.toString(), 10) >= 14 &&\n    ExpoTrackingTransparency\n  );\n}\n\nexport { PermissionResponse, PermissionStatus, PermissionExpiration };\n"]}
+{"version":3,"file":"TrackingTransparency.js","sourceRoot":"","sources":["../src/TrackingTransparency.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAGhB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,OAAO,wBAAwB,MAAM,4BAA4B,CAAC;AAElE,MAAM,gCAAgC,GAAuB;IAC3D,OAAO,EAAE,IAAI;IACb,OAAO,EAAE,OAAO;IAChB,WAAW,EAAE,IAAI;IACjB,MAAM,EAAE,gBAAgB,CAAC,OAAO;CACjC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,+BAA+B;IACnD,IAAI,QAAQ,CAAC,EAAE,KAAK,KAAK,EAAE;QACzB,OAAO,OAAO,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;KAC1D;IAED,IAAI,CAAC,wBAAwB,CAAC,uBAAuB,EAAE;QACrD,MAAM,IAAI,mBAAmB,CAAC,sBAAsB,EAAE,yBAAyB,CAAC,CAAC;KAClF;IACD,OAAO,MAAM,wBAAwB,CAAC,uBAAuB,EAAE,CAAC;AAClE,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B;IAC/C,IAAI,QAAQ,CAAC,EAAE,KAAK,KAAK,EAAE;QACzB,OAAO,OAAO,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;KAC1D;IAED,IAAI,CAAC,wBAAwB,CAAC,mBAAmB,EAAE;QACjD,MAAM,IAAI,mBAAmB,CAAC,sBAAsB,EAAE,qBAAqB,CAAC,CAAC;KAC9E;IACD,OAAO,MAAM,wBAAwB,CAAC,mBAAmB,EAAE,CAAC;AAC9D,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,oBAAoB,CAAC;IACzD,SAAS,EAAE,2BAA2B;IACtC,aAAa,EAAE,+BAA+B;CAC/C,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,WAAW;IACzB,OAAO,CACL,QAAQ,CAAC,EAAE,KAAK,KAAK;QACrB,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE;QAC/C,wBAAwB,CACzB,CAAC;AACJ,CAAC;AAED,OAAO,EAAsB,gBAAgB,EAA+C,CAAC","sourcesContent":["import {\n  PermissionResponse,\n  PermissionStatus,\n  PermissionExpiration,\n  PermissionHookOptions,\n  UnavailabilityError,\n  createPermissionHook,\n} from 'expo-modules-core';\nimport { Platform } from 'react-native';\n\nimport ExpoTrackingTransparency from './ExpoTrackingTransparency';\n\nconst androidAndWebPermissionsResponse: PermissionResponse = {\n  granted: true,\n  expires: 'never',\n  canAskAgain: true,\n  status: PermissionStatus.GRANTED,\n};\n\n/**\n * Requests the user to authorize or deny access to app-related data that can be used for tracking\n * the user or the device. Examples of data used for tracking include email address, device ID,\n * advertising ID, etc. On iOS 14.5 and above, if the user denies this permission, any attempt to\n * collect the IDFA will return a string of 0s.\n *\n * The system remembers the user’s choice and doesn’t prompt again unless a user uninstalls and then\n * reinstalls the app on the device.\n *\n * On Android, web, and iOS 13 and below, this method always returns that the permission was\n * granted.\n * @example\n * ```typescript\n * const { granted } = await requestTrackingPermissionsAsync();\n *\n * if (granted) {\n *   // Your app is authorized to track the user or their device\n * }\n * ```\n */\nexport async function requestTrackingPermissionsAsync(): Promise<PermissionResponse> {\n  if (Platform.OS !== 'ios') {\n    return Promise.resolve(androidAndWebPermissionsResponse);\n  }\n\n  if (!ExpoTrackingTransparency.requestPermissionsAsync) {\n    throw new UnavailabilityError('TrackingTransparency', 'requestPermissionsAsync');\n  }\n  return await ExpoTrackingTransparency.requestPermissionsAsync();\n}\n\n/**\n * Checks whether or not the user has authorized the app to access app-related data that can be used\n * for tracking the user or the device. See `requestTrackingPermissionsAsync` for more details.\n *\n * On Android, web, and iOS 13 and below, this method always returns that the permission was\n * granted.\n *\n * @example\n * ```typescript\n * const { granted } = await getTrackingPermissionsAsync();\n *\n * if (granted) {\n *   // Your app is authorized to track the user or their device\n * }\n * ```\n */\nexport async function getTrackingPermissionsAsync(): Promise<PermissionResponse> {\n  if (Platform.OS !== 'ios') {\n    return Promise.resolve(androidAndWebPermissionsResponse);\n  }\n\n  if (!ExpoTrackingTransparency.getPermissionsAsync) {\n    throw new UnavailabilityError('TrackingTransparency', 'getPermissionsAsync');\n  }\n  return await ExpoTrackingTransparency.getPermissionsAsync();\n}\n\n/**\n * Check or request the user to authorize or deny access to app-related data that can be used for tracking\n * the user or the device. Examples of data used for tracking include email address, device ID,\n * advertising ID, etc. On iOS 14.5 and above, if the user denies this permission, any attempt to\n * collect the IDFA will return a string of 0s.\n *\n * The system remembers the user’s choice and doesn’t prompt again unless a user uninstalls and then\n * reinstalls the app on the device.\n *\n * On Android, web, and iOS 13 and below, this method always returns that the permission was\n * granted.\n * @example\n * ```ts\n * const [status, requestPermission] = useTrackingPermissions();\n * ```\n */\nexport const useTrackingPermissions = createPermissionHook({\n  getMethod: getTrackingPermissionsAsync,\n  requestMethod: requestTrackingPermissionsAsync,\n});\n\n/**\n * Returns whether the TrackingTransparency API is available on the current device.\n *\n * @returns Currently this is `true` on iOS 14 and above only. On devices where the\n * Tracking Transparency API is unavailable, the get and request permissions methods will always\n * resolve to `granted`.\n */\nexport function isAvailable(): boolean {\n  return (\n    Platform.OS === 'ios' &&\n    parseInt(Platform.Version.toString(), 10) >= 14 &&\n    ExpoTrackingTransparency\n  );\n}\n\nexport { PermissionResponse, PermissionStatus, PermissionExpiration, PermissionHookOptions };\n"]}

package/expo-module.config.json

@@ -0,0 +1,7 @@
+{
+  "name": "expo-tracking-transparency",
+  "platforms": ["ios"],
+  "ios": {
+    "modulesClassNames": ["TrackingTransparencyModule"]
+  }
+}

package/ios/EXTrackingTransparency/EXTrackingPermissionRequester.m

@@ -39,12 +39,12 @@ NS_ASSUME_NONNULL_BEGIN
   };
 }
 
-- (void)requestPermissionsWithResolver:(UMPromiseResolveBlock)resolve rejecter:(UMPromiseRejectBlock)reject
+- (void)requestPermissionsWithResolver:(EXPromiseResolveBlock)resolve rejecter:(EXPromiseRejectBlock)reject
 {
   if (@available(iOS 14, *)) {
-    UM_WEAKIFY(self)
+    EX_WEAKIFY(self)
     [ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {
-      UM_STRONGIFY(self)
+      EX_STRONGIFY(self)
       resolve([self getPermissions]);
     }];
   } else {

package/ios/EXTrackingTransparency/EXTrackingTransparencyModule.h

@@ -1,11 +1,11 @@
 // Copyright 2021-present 650 Industries. All rights reserved.
 
-#import <UMCore/UMExportedModule.h>
-#import <UMCore/UMModuleRegistryConsumer.h>
+#import <ExpoModulesCore/EXExportedModule.h>
+#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
-@interface EXTrackingTransparencyModule : UMExportedModule <UMModuleRegistryConsumer>
+@interface EXTrackingTransparencyModule : EXExportedModule <EXModuleRegistryConsumer>
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/EXTrackingTransparency/EXTrackingTransparencyModule.m

@@ -16,17 +16,17 @@ NS_ASSUME_NONNULL_BEGIN
 
 @implementation EXTrackingTransparencyModule
 
-UM_EXPORT_MODULE(ExpoTrackingTransparency);
+EX_EXPORT_MODULE(ExpoTrackingTransparency);
 
-- (void)setModuleRegistry:(UMModuleRegistry *)moduleRegistry
+- (void)setModuleRegistry:(EXModuleRegistry *)moduleRegistry
 {
   _permissionsManager = [moduleRegistry getModuleImplementingProtocol:@protocol(EXPermissionsInterface)];
   [EXPermissionsMethodsDelegate registerRequesters:@[[EXTrackingPermissionRequester new]] withPermissionsManager:_permissionsManager];
 }
 
-UM_EXPORT_METHOD_AS(getPermissionsAsync,
-                    getPermissionsAsync:(UMPromiseResolveBlock)resolve
-                    rejecter:(UMPromiseRejectBlock)reject)
+EX_EXPORT_METHOD_AS(getPermissionsAsync,
+                    getPermissionsAsync:(EXPromiseResolveBlock)resolve
+                    rejecter:(EXPromiseRejectBlock)reject)
 {
   [EXPermissionsMethodsDelegate getPermissionWithPermissionsManager:_permissionsManager
                                                       withRequester:[EXTrackingPermissionRequester class]
@@ -34,9 +34,9 @@ UM_EXPORT_METHOD_AS(getPermissionsAsync,
                                                              reject:reject];
 }
 
-UM_EXPORT_METHOD_AS(requestPermissionsAsync,
-                    requestPermissionsAsync:(UMPromiseResolveBlock)resolve
-                    rejecter:(UMPromiseRejectBlock)reject)
+EX_EXPORT_METHOD_AS(requestPermissionsAsync,
+                    requestPermissionsAsync:(EXPromiseResolveBlock)resolve
+                    rejecter:(EXPromiseRejectBlock)reject)
 {
   [EXPermissionsMethodsDelegate askForPermissionWithPermissionsManager:_permissionsManager
                                                          withRequester:[EXTrackingPermissionRequester class]

package/ios/EXTrackingTransparency/TrackingTransparencyModule.swift

@@ -0,0 +1,29 @@
+import ExpoModulesCore
+
+public class TrackingTransparencyModule: Module {
+  public func definition() -> ModuleDefinition {
+    name("ExpoTrackingTransparency")
+
+    onCreate {
+      EXPermissionsMethodsDelegate.register([EXTrackingPermissionRequester()], withPermissionsManager: self.appContext?.permissions)
+    }
+
+    method("getPermissionsAsync") { (promise: Promise) in
+      EXPermissionsMethodsDelegate.getPermissionWithPermissionsManager(
+        self.appContext?.permissions,
+        withRequester: EXTrackingPermissionRequester.self,
+        resolve: promise.resolver,
+        reject: promise.legacyRejecter
+      )
+    }
+
+    method("requestPermissionsAsync") { (promise: Promise) in
+      EXPermissionsMethodsDelegate.askForPermission(
+        withPermissionsManager: self.appContext?.permissions,
+        withRequester: EXTrackingPermissionRequester.self,
+        resolve: promise.resolver,
+        reject: promise.legacyRejecter
+      )
+    }
+  }
+}

package/ios/EXTrackingTransparency.podspec

@@ -10,15 +10,22 @@ Pod::Spec.new do |s|
   s.license        = package['license']
   s.author         = package['author']
   s.homepage       = package['homepage']
-  s.platform       = :ios, '11.0'
+  s.platform       = :ios, '12.0'
+  s.swift_version  = '5.4'
   s.source         = { git: 'https://github.com/expo/expo.git' }
+  s.static_framework = true
 
-  s.dependency 'UMCore'
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES'
+  }
 
   if !$ExpoUseSources&.include?(package['name']) && ENV['EXPO_USE_SOURCE'].to_i == 0 && File.exist?("#{s.name}.xcframework") && Gem::Version.new(Pod::VERSION) >= Gem::Version.new('1.10.0')
     s.source_files = "#{s.name}/**/*.h"
     s.vendored_frameworks = "#{s.name}.xcframework"
   else
-    s.source_files = "#{s.name}/**/*.{h,m}"
+    s.source_files = "#{s.name}/**/*.{h,m,swift}"
   end
 end

package/ios/Info-generated.plist

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>expo.tracking.transparency</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>EXTrackingTransparency</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.1.0</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+</dict>
+</plist>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-tracking-transparency",
-  "version": "1.1.2",
+  "version": "2.0.3",
   "description": "An Expo library for requesting permission to track the users on devices using iOS 14.5 and higher.",
   "main": "build/TrackingTransparency.js",
   "types": "build/TrackingTransparency.d.ts",
@@ -28,10 +28,10 @@
   },
   "author": "650 Industries, Inc.",
   "license": "MIT",
-  "homepage": "https://docs.expo.io/versions/latest/sdk/module-template",
+  "homepage": "https://docs.expo.dev/versions/latest/sdk/module-template",
   "dependencies": {
-    "@expo/config-plugins": "^3.0.0",
-    "expo-modules-core": "~0.2.0"
+    "@expo/config-plugins": "^4.0.2",
+    "expo-modules-core": "~0.4.4"
   },
   "devDependencies": {
     "expo-module-scripts": "^2.0.0"
@@ -39,5 +39,5 @@
   "jest": {
     "preset": "expo-module-scripts/ios"
   },
-  "gitHead": "4fc9d282ff7ab2fa9040b775aeca7c30f5167b17"
+  "gitHead": "4fa0497a180ae707fa860cb03858630ab7af19f4"
 }

package/plugin/build/withTrackingTransparency.js

@@ -8,7 +8,7 @@ const withTrackingTransparency = (config, props) => {
     config = exports.withUserTrackingPermission(config, props);
     return config;
 };
-exports.withUserTrackingPermission = (config, { userTrackingPermission } = {}) => {
+const withUserTrackingPermission = (config, { userTrackingPermission } = {}) => {
     if (!config.ios)
         config.ios = {};
     if (!config.ios.infoPlist)
@@ -19,4 +19,5 @@ exports.withUserTrackingPermission = (config, { userTrackingPermission } = {}) =
             exports.DEFAULT_NSUserTrackingUsageDescription;
     return config;
 };
+exports.withUserTrackingPermission = withUserTrackingPermission;
 exports.default = config_plugins_1.createRunOncePlugin(withTrackingTransparency, pkg.name, pkg.version);

package/src/ExpoTrackingTransparency.ts

@@ -1,3 +1,3 @@
-import { NativeModulesProxy } from '@unimodules/core';
+import { NativeModulesProxy } from 'expo-modules-core';
 
 export default NativeModulesProxy.ExpoTrackingTransparency;

package/src/TrackingTransparency.ts

@@ -1,5 +1,11 @@
-import { UnavailabilityError } from '@unimodules/core';
-import { PermissionResponse, PermissionStatus, PermissionExpiration } from 'expo-modules-core';
+import {
+  PermissionResponse,
+  PermissionStatus,
+  PermissionExpiration,
+  PermissionHookOptions,
+  UnavailabilityError,
+  createPermissionHook,
+} from 'expo-modules-core';
 import { Platform } from 'react-native';
 
 import ExpoTrackingTransparency from './ExpoTrackingTransparency';
@@ -44,7 +50,7 @@ export async function requestTrackingPermissionsAsync(): Promise<PermissionRespo
 
 /**
  * Checks whether or not the user has authorized the app to access app-related data that can be used
- * for tracking the user or the device. See `requestPermissionsAsync` for more details.
+ * for tracking the user or the device. See `requestTrackingPermissionsAsync` for more details.
  *
  * On Android, web, and iOS 13 and below, this method always returns that the permission was
  * granted.
@@ -69,6 +75,27 @@ export async function getTrackingPermissionsAsync(): Promise<PermissionResponse>
   return await ExpoTrackingTransparency.getPermissionsAsync();
 }
 
+/**
+ * Check or request the user to authorize or deny access to app-related data that can be used for tracking
+ * the user or the device. Examples of data used for tracking include email address, device ID,
+ * advertising ID, etc. On iOS 14.5 and above, if the user denies this permission, any attempt to
+ * collect the IDFA will return a string of 0s.
+ *
+ * The system remembers the user’s choice and doesn’t prompt again unless a user uninstalls and then
+ * reinstalls the app on the device.
+ *
+ * On Android, web, and iOS 13 and below, this method always returns that the permission was
+ * granted.
+ * @example
+ * ```ts
+ * const [status, requestPermission] = useTrackingPermissions();
+ * ```
+ */
+export const useTrackingPermissions = createPermissionHook({
+  getMethod: getTrackingPermissionsAsync,
+  requestMethod: requestTrackingPermissionsAsync,
+});
+
 /**
  * Returns whether the TrackingTransparency API is available on the current device.
  *
@@ -84,4 +111,4 @@ export function isAvailable(): boolean {
   );
 }
 
-export { PermissionResponse, PermissionStatus, PermissionExpiration };
+export { PermissionResponse, PermissionStatus, PermissionExpiration, PermissionHookOptions };