expo-device 5.0.0 → 5.2.0

package/ios/UIDevice.swift

@@ -0,0 +1,261 @@
+import UIKit
+
+struct ExpoDeviceType {
+  let modelName: String
+  let deviceYearClass: Int?
+}
+
+public extension UIDevice {
+  // Credit: https://stackoverflow.com/a/26962452
+  static let modelIdentifier: String = {
+    var systemInfo = utsname()
+    uname(&systemInfo)
+    let machineMirror = Mirror(reflecting: systemInfo.machine)
+    let identifier = machineMirror.children.reduce("") { identifier, element in
+      guard let value = element.value as? Int8, value != 0 else {
+        return identifier
+      }
+      return identifier + String(UnicodeScalar(UInt8(value)))
+    }
+
+    return identifier
+  }()
+
+  // swiftlint:disable function_body_length closure_body_length
+  static internal let DeviceMap: ExpoDeviceType = {
+    func mapToDevice(identifier: String) -> ExpoDeviceType {
+      let currentYear = Calendar(identifier: .gregorian).dateComponents([.year], from: Date()).year
+
+      #if os(iOS)
+      switch identifier {
+      case "iPod7,1":
+        return ExpoDeviceType(modelName: "iPod touch (6th generation)", deviceYearClass: 2015)
+      case "iPod9,1":
+        return ExpoDeviceType(modelName: "iPod touch (7th generation)", deviceYearClass: 2019)
+      case "iPhone6,1", "iPhone6,2":
+        return ExpoDeviceType(modelName: "iPhone 5s", deviceYearClass: 2013)
+      case "iPhone7,1":
+        return ExpoDeviceType(modelName: "iPhone 6 Plus", deviceYearClass: 2014)
+      case "iPhone7,2":
+        return ExpoDeviceType(modelName: "iPhone 6", deviceYearClass: 2014)
+      case "iPhone8,1":
+        return ExpoDeviceType(modelName: "iPhone 6s", deviceYearClass: 2015)
+      case "iPhone8,2":
+        return ExpoDeviceType(modelName: "iPhone 6s Plus", deviceYearClass: 2015)
+      case "iPhone9,1", "iPhone9,3":
+        return ExpoDeviceType(modelName: "iPhone 7", deviceYearClass: 2016)
+      case "iPhone9,2", "iPhone9,4":
+        return ExpoDeviceType(modelName: "iPhone 7 Plus", deviceYearClass: 2016)
+      case "iPhone10,1", "iPhone10,4":
+        return ExpoDeviceType(modelName: "iPhone 8", deviceYearClass: 2017)
+      case "iPhone10,2", "iPhone10,5":
+        return ExpoDeviceType(modelName: "iPhone 8 Plus", deviceYearClass: 2017)
+      case "iPhone10,3", "iPhone10,6":
+        return ExpoDeviceType(modelName: "iPhone X", deviceYearClass: 2017)
+      case "iPhone11,2":
+        return ExpoDeviceType(modelName: "iPhone XS", deviceYearClass: 2018)
+      case "iPhone11,4", "iPhone11,6":
+        return ExpoDeviceType(modelName: "iPhone XS Max", deviceYearClass: 2018)
+      case "iPhone11,8":
+        return ExpoDeviceType(modelName: "iPhone XR", deviceYearClass: 2018)
+      case "iPhone12,1":
+        return ExpoDeviceType(modelName: "iPhone 11", deviceYearClass: 2019)
+      case "iPhone12,3":
+        return ExpoDeviceType(modelName: "iPhone 11 Pro", deviceYearClass: 2019)
+      case "iPhone12,5":
+        return ExpoDeviceType(modelName: "iPhone 11 Pro Max", deviceYearClass: 2019)
+      case "iPhone13,1":
+        return ExpoDeviceType(modelName: "iPhone 12 mini", deviceYearClass: 2020)
+      case "iPhone13,2":
+        return ExpoDeviceType(modelName: "iPhone 12", deviceYearClass: 2020)
+      case "iPhone13,3":
+        return ExpoDeviceType(modelName: "iPhone 12 Pro", deviceYearClass: 2020)
+      case "iPhone13,4":
+        return ExpoDeviceType(modelName: "iPhone 12 Pro Max", deviceYearClass: 2020)
+      case "iPhone14,4":
+        return ExpoDeviceType(modelName: "iPhone 13 mini", deviceYearClass: 2021)
+      case "iPhone14,5":
+        return ExpoDeviceType(modelName: "iPhone 13", deviceYearClass: 2021)
+      case "iPhone14,2":
+        return ExpoDeviceType(modelName: "iPhone 13 Pro", deviceYearClass: 2021)
+      case "iPhone14,3":
+        return ExpoDeviceType(modelName: "iPhone 13 Pro Max", deviceYearClass: 2021)
+      case "iPhone14,7":
+        return ExpoDeviceType(modelName: "iPhone 14", deviceYearClass: 2022)
+      case "iPhone14,8":
+        return ExpoDeviceType(modelName: "iPhone 14 Plus", deviceYearClass: 2022)
+      case "iPhone15,2":
+        return ExpoDeviceType(modelName: "iPhone 14 Pro", deviceYearClass: 2022)
+      case "iPhone15,3":
+        return ExpoDeviceType(modelName: "iPhone 14 Pro Max", deviceYearClass: 2022)
+      case "iPhone8,4":
+        return ExpoDeviceType(modelName: "iPhone SE", deviceYearClass: 2016)
+      case "iPhone12,8":
+        return ExpoDeviceType(modelName: "iPhone SE (2nd generation)", deviceYearClass: 2020)
+      case "iPhone14,6":
+        return ExpoDeviceType(modelName: "iPhone SE (3rd generation)", deviceYearClass: 2022)
+      case "iPad6,11", "iPad6,12":
+        return ExpoDeviceType(modelName: "iPad (5th generation)", deviceYearClass: 2017)
+      case "iPad7,5", "iPad7,6":
+        return ExpoDeviceType(modelName: "iPad (6th generation)", deviceYearClass: 2018)
+      case "iPad7,11", "iPad7,12":
+        return ExpoDeviceType(modelName: "iPad (7th generation)", deviceYearClass: 2019)
+      case "iPad11,6", "iPad11,7":
+        return ExpoDeviceType(modelName: "iPad (8th generation)", deviceYearClass: 2020)
+      case "iPad12,1", "iPad12,2":
+        return ExpoDeviceType(modelName: "iPad (9th generation)", deviceYearClass: 2021)
+      case "iPad4,1", "iPad4,2", "iPad4,3":
+        return ExpoDeviceType(modelName: "iPad Air", deviceYearClass: 2013)
+      case "iPad5,3", "iPad5,4":
+        return ExpoDeviceType(modelName: "iPad Air 2", deviceYearClass: 2014)
+      case "iPad11,3", "iPad11,4":
+        return ExpoDeviceType(modelName: "iPad Air (3rd generation)", deviceYearClass: 2019)
+      case "iPad13,1", "iPad13,2":
+        return ExpoDeviceType(modelName: "iPad Air (4th generation)", deviceYearClass: 2020)
+      case "iPad13,16", "iPad13,17":
+        return ExpoDeviceType(modelName: "iPad Air (5th generation)", deviceYearClass: 2022)
+      case "iPad4,4", "iPad4,5", "iPad4,6":
+        return ExpoDeviceType(modelName: "iPad mini 2", deviceYearClass: 2013)
+      case "iPad4,7", "iPad4,8", "iPad4,9":
+        return ExpoDeviceType(modelName: "iPad mini 3", deviceYearClass: 2014)
+      case "iPad5,1", "iPad5,2":
+        return ExpoDeviceType(modelName: "iPad mini 4", deviceYearClass: 2015)
+      case "iPad11,1", "iPad11,2":
+        return ExpoDeviceType(modelName: "iPad mini (5th generation)", deviceYearClass: 2019)
+      case "iPad14,1", "iPad14,2":
+        return ExpoDeviceType(modelName: "iPad mini (6th generation)", deviceYearClass: 2021)
+      case "iPad6,3", "iPad6,4":
+        return ExpoDeviceType(modelName: "iPad Pro (9.7-inch)", deviceYearClass: 2016)
+      case "iPad7,3", "iPad7,4":
+        return ExpoDeviceType(modelName: "iPad Pro (10.5-inch)", deviceYearClass: 2017)
+      case "iPad8,1", "iPad8,2", "iPad8,3", "iPad8,4":
+        return ExpoDeviceType(modelName: "iPad Pro (11-inch) (1st generation)", deviceYearClass: 2018)
+      case "iPad8,9", "iPad8,10":
+        return ExpoDeviceType(modelName: "iPad Pro (11-inch) (2nd generation)", deviceYearClass: 2020)
+      case "iPad13,4", "iPad13,5", "iPad13,6", "iPad13,7":
+        return ExpoDeviceType(modelName: "iPad Pro (11-inch) (3rd generation)", deviceYearClass: 2021)
+      case "iPad6,7", "iPad6,8":
+        return ExpoDeviceType(modelName: "iPad Pro (12.9-inch) (1st generation)", deviceYearClass: 2015)
+      case "iPad7,1", "iPad7,2":
+        return ExpoDeviceType(modelName: "iPad Pro (12.9-inch) (2nd generation)", deviceYearClass: 2017)
+      case "iPad8,5", "iPad8,6", "iPad8,7", "iPad8,8":
+        return ExpoDeviceType(modelName: "iPad Pro (12.9-inch) (3rd generation)", deviceYearClass: 2018)
+      case "iPad8,11", "iPad8,12":
+        return ExpoDeviceType(modelName: "iPad Pro (12.9-inch) (4th generation)", deviceYearClass: 2020)
+      case "iPad13,8", "iPad13,9", "iPad13,10", "iPad13,11":
+        return ExpoDeviceType(modelName: "iPad Pro (12.9-inch) (5th generation)", deviceYearClass: 2021)
+      case "AppleTV5,3":
+        return ExpoDeviceType(modelName: "Apple TV HD (4th Generation, Siri)", deviceYearClass: 2015)
+      case "AppleTV6,2":
+        return ExpoDeviceType(modelName: "Apple TV 4K", deviceYearClass: 2017)
+      case "i386", "x86_64", "arm64":
+        return ExpoDeviceType(modelName: "Simulator iOS", deviceYearClass: currentYear)
+      default:
+        return ExpoDeviceType(modelName: identifier, deviceYearClass: currentYear)
+      }
+      #elseif os(tvOS)
+      switch identifier {
+      case "AppleTV5,3":
+        return ExpoDeviceType(modelName: "Apple TV HD (4th Generation, Siri)", deviceYearClass: 2015)
+      case "AppleTV6,2":
+        return ExpoDeviceType(modelName: "Apple TV 4K", deviceYearClass: 2017)
+      case "i386", "x86_64":
+        return ExpoDeviceType(modelName: "Simulator tvOS", deviceYearClass: currentYear)
+      default:
+        return identifier
+      }
+      #endif
+    }
+
+    return mapToDevice(identifier: modelIdentifier)
+  }()
+  // swiftlint:enable function_body_length closure_body_length
+
+  // Credit: https://github.com/developerinsider/isJailBroken/blob/master/IsJailBroken/Extension/UIDevice%2BJailBroken.swift
+  var isSimulator: Bool {
+    return TARGET_OS_SIMULATOR != 0
+  }
+
+  var isJailbroken: Bool {
+    if UIDevice.current.isSimulator {
+      return false
+    }
+
+    let jailbroken = JailbreakHelper.hasCydiaInstalled() || JailbreakHelper.doesContainSuspiciousApps() ||
+    JailbreakHelper.doesSuspiciousSystemPathExist() || JailbreakHelper.canEditSystemFiles()
+
+    return jailbroken
+  }
+}
+
+// Credit: https://github.com/developerinsider/isJailBroken/blob/master/IsJailBroken/Extension/UIDevice%2BJailBroken.swift
+private struct JailbreakHelper {
+  static func hasCydiaInstalled() -> Bool {
+    if let url = URL(string: "cydia://") {
+      return UIApplication.shared.canOpenURL(url)
+    }
+    return false
+  }
+
+  static func doesContainSuspiciousApps() -> Bool {
+    for path in suspiciousAppsPathToCheck where FileManager.default.fileExists(atPath: path) {
+      return true
+    }
+    return false
+  }
+
+  static func doesSuspiciousSystemPathExist() -> Bool {
+    for path in suspiciousSystemPathsToCheck where FileManager.default.fileExists(atPath: path) {
+      return true
+    }
+    return false
+  }
+
+  static func canEditSystemFiles() -> Bool {
+    let jailbreakText = "Developer Insider"
+    do {
+      try jailbreakText.write(toFile: jailbreakText, atomically: true, encoding: .utf8)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   Add more paths here to check for jail break
+   */
+  static var suspiciousAppsPathToCheck: [String] {
+    return [
+      "/Applications/Cydia.app",
+      "/Applications/blackra1n.app",
+      "/Applications/FakeCarrier.app",
+      "/Applications/Icy.app",
+      "/Applications/IntelliScreen.app",
+      "/Applications/MxTube.app",
+      "/Applications/RockApp.app",
+      "/Applications/SBSettings.app",
+      "/Applications/WinterBoard.app"
+    ]
+  }
+
+  static var suspiciousSystemPathsToCheck: [String] {
+    return [
+      "/Library/MobileSubstrate/DynamicLibraries/LiveClock.plist",
+      "/Library/MobileSubstrate/DynamicLibraries/Veency.plist",
+      "/private/var/lib/apt",
+      "/private/var/lib/apt/",
+      "/private/var/lib/cydia",
+      "/private/var/mobile/Library/SBSettings/Themes",
+      "/private/var/stash",
+      "/private/var/tmp/cydia.log",
+      "/System/Library/LaunchDaemons/com.ikey.bbot.plist",
+      "/System/Library/LaunchDaemons/com.saurik.Cydia.Startup.plist",
+      "/usr/bin/sshd",
+      "/usr/libexec/sftp-server",
+      "/usr/sbin/sshd",
+      "/etc/apt",
+      "/bin/bash",
+      "/Library/MobileSubstrate/MobileSubstrate.dylib"
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-device",
-  "version": "5.0.0",
+  "version": "5.2.0",
   "description": "A universal module that gets physical information about the device running the application",
   "main": "build/Device.js",
   "types": "build/Device.d.ts",
@@ -33,7 +33,7 @@
   "license": "MIT",
   "homepage": "https://docs.expo.dev/versions/latest/sdk/device/",
   "dependencies": {
-    "ua-parser-js": "^0.7.19"
+    "ua-parser-js": "^0.7.33"
   },
   "devDependencies": {
     "expo-module-scripts": "^3.0.0"
@@ -41,5 +41,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "eab2b09c735fb0fc2bf734a3f29a6593adba3838"
+  "gitHead": "1815e2eaad8c753588c7b1eb74420174a28e01f4"
 }

package/src/Device.ts

@@ -5,30 +5,216 @@ import ExpoDevice from './ExpoDevice';
 
 export { DeviceType };
 
+/**
+ * `true` if the app is running on a real device and `false` if running in a simulator or emulator.
+ * On web, this is always set to `true`.
+ */
 export const isDevice: boolean = ExpoDevice ? ExpoDevice.isDevice : true;
+
+/**
+ * The device brand. The consumer-visible brand of the product/hardware. On web, this value is always `null`.
+ *
+ * @example
+ * ```js
+ * Device.brand; // Android: "google", "xiaomi"; iOS: "Apple"; web: null
+ * ```
+ * @platform android
+ * @platform ios
+ */
 export const brand: string | null = ExpoDevice ? ExpoDevice.brand : null;
+
+/**
+ * The actual device manufacturer of the product or hardware. This value of this field may be `null` if it cannot be determined.
+ *
+ * To view difference between `brand` and `manufacturer` on Android see [official documentation](https://developer.android.com/reference/android/os/Build).
+ *
+ * @example
+ * ```js
+ * Device.manufacturer; // Android: "Google", "xiaomi"; iOS: "Apple"; web: "Google", null
+ * ```
+ */
 export const manufacturer: string | null = ExpoDevice ? ExpoDevice.manufacturer : null;
+
+/**
+ * The internal model ID of the device. This is useful for programmatically identifying the type of device and is not a human-friendly string.
+ * On web and Android, this value is always `null`.
+ *
+ * @example
+ * ```js
+ * Device.modelId; // iOS: "iPhone7,2"; Android: null; web: null
+ * ```
+ * @platform ios
+ */
 export const modelId = ExpoDevice ? ExpoDevice.modelId || null : null;
+
+/**
+ * The human-friendly name of the device model. This is the name that people would typically use to refer to the device rather than a programmatic model identifier.
+ * This value of this field may be `null` if it cannot be determined.
+ *
+ * @example
+ * ```js
+ * Device.modelName; // Android: "Pixel 2"; iOS: "iPhone XS Max"; web: "iPhone", null
+ * ```
+ */
 export const modelName: string | null = ExpoDevice ? ExpoDevice.modelName : null;
+
+/**
+ * The specific configuration or name of the industrial design. It represents the device's name when it was designed during manufacturing into mass production.
+ * On Android, it corresponds to [`Build.DEVICE`](https://developer.android.com/reference/android/os/Build#DEVICE). On web and iOS, this value is always `null`.
+ *
+ * @example
+ * ```js
+ * Device.designName; // Android: "kminilte"; iOS: null; web: null
+ * ```
+ * @platform android
+ */
 export const designName: string | null = ExpoDevice ? ExpoDevice.designName || null : null;
+
+/**
+ * The device's overall product name chosen by the device implementer containing the development name or code name of the device.
+ * Corresponds to [`Build.PRODUCT`](https://developer.android.com/reference/android/os/Build#PRODUCT). On web and iOS, this value is always `null`.
+ *
+ * @example
+ * ```js
+ * Device.productName; // Android: "kminiltexx"; iOS: null; web: null
+ * ```
+ * @platform android
+ */
 export const productName: string | null = ExpoDevice ? ExpoDevice.productName || null : null;
+
+/**
+ * The [device year class](https://github.com/facebook/device-year-class) of this device. On web, this value is always `null`.
+ */
 export const deviceYearClass: number | null = ExpoDevice ? ExpoDevice.deviceYearClass : null;
+
+/**
+ * The device's total memory, in bytes. This is the total memory accessible to the kernel, but not necessarily to a single app.
+ * This is basically the amount of RAM the device has, not including below-kernel fixed allocations like DMA buffers, RAM for the baseband CPU, etc…
+ * On web, this value is always `null`.
+ *
+ * @example
+ * ```js
+ * Device.totalMemory; // 17179869184
+ * ```
+ */
 export const totalMemory: number | null = ExpoDevice ? ExpoDevice.totalMemory : null;
+
+/**
+ * A list of supported processor architecture versions. The device expects the binaries it runs to be compiled for one of these architectures.
+ * This value is `null` if the supported architectures could not be determined, particularly on web.
+ *
+ * @example
+ * ```js
+ * Device.supportedCpuArchitectures; // ['arm64 v8', 'Intel x86-64h Haswell', 'arm64-v8a', 'armeabi-v7a", 'armeabi']
+ * ```
+ */
 export const supportedCpuArchitectures: string[] | null = ExpoDevice
   ? ExpoDevice.supportedCpuArchitectures
   : null;
+
+/**
+ * The name of the OS running on the device.
+ *
+ * @example
+ * ```js
+ * Device.osName; // Android: "Android"; iOS: "iOS" or "iPadOS"; web: "iOS", "Android", "Windows"
+ * ```
+ */
 export const osName: string | null = ExpoDevice ? ExpoDevice.osName : null;
+
+/**
+ * The human-readable OS version string. Note that the version string may not always contain three numbers separated by dots.
+ *
+ * @example
+ * ```js
+ * Device.osVersion; // Android: "4.0.3"; iOS: "12.3.1"; web: "11.0", "8.1.0"
+ * ```
+ */
 export const osVersion: string | null = ExpoDevice ? ExpoDevice.osVersion : null;
+
+/**
+ * The build ID of the OS that more precisely identifies the version of the OS. On Android, this corresponds to `Build.DISPLAY` (not `Build.ID`)
+ * and currently is a string as described [here](https://source.android.com/setup/start/build-numbers). On iOS, this corresponds to `kern.osversion`
+ * and is the detailed OS version sometimes displayed next to the more human-readable version. On web, this value is always `null`.
+ *
+ * @example
+ * ```js
+ * Device.osBuildId; // Android: "PSR1.180720.075"; iOS: "16F203"; web: null
+ * ```
+ */
 export const osBuildId: string | null = ExpoDevice ? ExpoDevice.osBuildId : null;
+
+/**
+ * The internal build ID of the OS running on the device. On Android, this corresponds to `Build.ID`.
+ * On iOS, this is the same value as [`Device.osBuildId`](#deviceosbuildid). On web, this value is always `null`.
+ *
+ * @example
+ * ```js
+ * Device.osInternalBuildId; // Android: "MMB29K"; iOS: "16F203"; web: null,
+ * ```
+ */
 export const osInternalBuildId: string | null = ExpoDevice ? ExpoDevice.osInternalBuildId : null;
+
+/**
+ * A string that uniquely identifies the build of the currently running system OS. On Android, it follows this template:
+ * - `$(BRAND)/$(PRODUCT)/$(DEVICE)/$(BOARD):$(VERSION.RELEASE)/$(ID)/$(VERSION.INCREMENTAL):$(TYPE)/\$(TAGS)`
+ * On web and iOS, this value is always `null`.
+ *
+ * @example
+ * ```js
+ * Device.osBuildFingerprint;
+ * // Android: "google/sdk_gphone_x86/generic_x86:9/PSR1.180720.075/5124027:user/release-keys";
+ * // iOS: null; web: null
+ * ```
+ * @platform android
+ */
 export const osBuildFingerprint: string | null = ExpoDevice
   ? ExpoDevice.osBuildFingerprint || null
   : null;
+
+/**
+ * The Android SDK version of the software currently running on this hardware device. This value never changes while a device is booted,
+ * but it may increase when the hardware manufacturer provides an OS update. See [here](https://developer.android.com/reference/android/os/Build.VERSION_CODES.html)
+ * to see all possible version codes and corresponding versions. On iOS and web, this value is always `null`.
+ *
+ * @example
+ * ```js
+ * Device.platformApiLevel; // Android: 19; iOS: null; web: null
+ * ```
+ * @platform android
+ */
 export const platformApiLevel: number | null = ExpoDevice
   ? ExpoDevice.platformApiLevel || null
   : null;
+
+/**
+ * The human-readable name of the device, which may be set by the device's user. If the device name is unavailable, particularly on web, this value is `null`.
+ *
+ * > On iOS 16 and newer, this value will be set to generic "iPhone" until you add the correct entitlement, see [iOS Capabilities page](/build-reference/ios-capabilities)
+ * > to learn how to add one and check out [Apple documentation](https://developer.apple.com/documentation/uikit/uidevice/1620015-name#discussion)
+ * > for more details on this change.
+ *
+ * @example
+ * ```js
+ * Device.deviceName; // "Vivian's iPhone XS"
+ * ```
+ */
 export const deviceName: string | null = ExpoDevice ? ExpoDevice.deviceName : null;
 
+/**
+ * Checks the type of the device as a [`DeviceType`](#devicetype) enum value.
+ *
+ * On Android, for devices other than TVs, the device type is determined by the screen resolution (screen diagonal size), so the result may not be completely accurate.
+ * If the screen diagonal length is between 3" and 6.9", the method returns `DeviceType.PHONE`. For lengths between 7" and 18", the method returns `DeviceType.TABLET`.
+ * Otherwise, the method returns `DeviceType.UNKNOWN`.
+ *
+ * @return Returns a promise that resolves to a [`DeviceType`](#devicetype) enum value.
+ * @example
+ * ```js
+ * await Device.getDeviceTypeAsync();
+ * // DeviceType.PHONE
+ * ```
+ */
 export async function getDeviceTypeAsync(): Promise<DeviceType> {
   if (!ExpoDevice.getDeviceTypeAsync) {
     throw new UnavailabilityError('expo-device', 'getDeviceTypeAsync');
@@ -36,6 +222,17 @@ export async function getDeviceTypeAsync(): Promise<DeviceType> {
   return await ExpoDevice.getDeviceTypeAsync();
 }
 
+/**
+ * Gets the uptime since the last reboot of the device, in milliseconds. Android devices do not count time spent in deep sleep.
+ * @return Returns a promise that resolves to a `number` that represents the milliseconds since last reboot.
+ * @example
+ * ```js
+ * await Device.getUptimeAsync();
+ * // 4371054
+ * ```
+ * @platform android
+ * @platform ios
+ */
 export async function getUptimeAsync(): Promise<number> {
   if (!ExpoDevice.getUptimeAsync) {
     throw new UnavailabilityError('expo-device', 'getUptimeAsync');
@@ -43,6 +240,16 @@ export async function getUptimeAsync(): Promise<number> {
   return await ExpoDevice.getUptimeAsync();
 }
 
+/**
+ * Returns the maximum amount of memory that the Java VM will attempt to use. If there is no inherent limit then `Number.MAX_SAFE_INTEGER` is returned.
+ * @return Returns a promise that resolves to the maximum available memory that the Java VM will use, in bytes.
+ * @example
+ * ```js
+ * await Device.getMaxMemoryAsync();
+ * // 402653184
+ * ```
+ * @platform android
+ */
 export async function getMaxMemoryAsync(): Promise<number> {
   if (!ExpoDevice.getMaxMemoryAsync) {
     throw new UnavailabilityError('expo-device', 'getMaxMemoryAsync');
@@ -54,6 +261,22 @@ export async function getMaxMemoryAsync(): Promise<number> {
   return maxMemory;
 }
 
+/**
+ * > **warning** This method is experimental and is not completely reliable. See description below.
+ *
+ * Checks whether the device has been rooted (Android) or jailbroken (iOS). This is not completely reliable because there exist solutions to bypass root-detection
+ * on both [iOS](https://www.theiphonewiki.com/wiki/XCon) and [Android](https://tweakerlinks.com/how-to-bypass-apps-root-detection-in-android-device/).
+ * Further, many root-detection checks can be bypassed via reverse engineering.
+ * - On Android, it's implemented in a way to find all possible files paths that contain the `"su"` executable but some devices that are not rooted may also have this executable. Therefore, there's no guarantee that this method will always return correctly.
+ * - On iOS, [these jailbreak checks](https://www.theiphonewiki.com/wiki/Bypassing_Jailbreak_Detection) are used to detect if a device is rooted/jailbroken. However, since there are closed-sourced solutions such as [xCon](https://www.theiphonewiki.com/wiki/XCon) that aim to hook every known method and function responsible for informing an application of a jailbroken device, this method may not reliably detect devices that have xCon or similar packages installed.
+ * - On web, this always resolves to `false` even if the device is rooted.
+ * @return Returns a promise that resolves to a `boolean` that specifies whether this device is rooted.
+ * @example
+ * ```js
+ * await Device.isRootedExperimentalAsync();
+ * // true or false
+ * ```
+ */
 export async function isRootedExperimentalAsync(): Promise<boolean> {
   if (!ExpoDevice.isRootedExperimentalAsync) {
     throw new UnavailabilityError('expo-device', 'isRootedExperimentalAsync');
@@ -61,6 +284,18 @@ export async function isRootedExperimentalAsync(): Promise<boolean> {
   return await ExpoDevice.isRootedExperimentalAsync();
 }
 
+/**
+ * **Using this method requires you to [add the `REQUEST_INSTALL_PACKAGES` permission](/config/app#permissions).**
+ * Returns whether applications can be installed for this user via the system's [Intent#ACTION_INSTALL_PACKAGE](https://developer.android.com/reference/android/content/Intent.html#ACTION_INSTALL_PACKAGE)
+ * mechanism rather than through the OS's default app store, like Google Play.
+ * @return Returns a promise that resolves to a `boolean` that represents whether the calling package is allowed to request package installation.
+ * @example
+ * ```js
+ * await Device.isSideLoadingEnabledAsync();
+ * // true or false
+ * ```
+ * @platform android
+ */
 export async function isSideLoadingEnabledAsync(): Promise<boolean> {
   if (!ExpoDevice.isSideLoadingEnabledAsync) {
     throw new UnavailabilityError('expo-device', 'isSideLoadingEnabledAsync');
@@ -68,6 +303,24 @@ export async function isSideLoadingEnabledAsync(): Promise<boolean> {
   return await ExpoDevice.isSideLoadingEnabledAsync();
 }
 
+/**
+ * Gets a list of features that are available on the system. The feature names are platform-specific.
+ * See [Android documentation](<https://developer.android.com/reference/android/content/pm/PackageManager#getSystemAvailableFeatures()>)
+ * to learn more about this implementation.
+ * @return Returns a promise that resolves to an array of strings, each of which is a platform-specific name of a feature available on the current device.
+ * On iOS and web, the promise always resolves to an empty array.
+ * @example
+ * ```js
+ * await Device.getPlatformFeaturesAsync();
+ * // [
+ * //   'android.software.adoptable_storage',
+ * //   'android.software.backup',
+ * //   'android.hardware.sensor.accelerometer',
+ * //   'android.hardware.touchscreen',
+ * // ]
+ * ```
+ * @platform android
+ */
 export async function getPlatformFeaturesAsync(): Promise<string[]> {
   if (!ExpoDevice.getPlatformFeaturesAsync) {
     return [];
@@ -75,6 +328,19 @@ export async function getPlatformFeaturesAsync(): Promise<string[]> {
   return await ExpoDevice.getPlatformFeaturesAsync();
 }
 
+/**
+ * Tells if the device has a specific system feature.
+ * @param feature The platform-specific name of the feature to check for on the device. You can get all available system features with `Device.getSystemFeatureAsync()`.
+ * See [Android documentation](<https://developer.android.com/reference/android/content/pm/PackageManager#hasSystemFeature(java.lang.String)>) to view acceptable feature strings.
+ * @return Returns a promise that resolves to a boolean value indicating whether the device has the specified system feature.
+ * On iOS and web, the promise always resolves to `false`.
+ * @example
+ * ```js
+ * await Device.hasPlatformFeatureAsync('amazon.hardware.fire_tv');
+ * // true or false
+ * ```
+ * @platform android
+ */
 export async function hasPlatformFeatureAsync(feature: string): Promise<boolean> {
   if (!ExpoDevice.hasPlatformFeatureAsync) {
     return false;

package/src/Device.types.ts

@@ -1,7 +1,25 @@
+/**
+ * An enum representing the different types of devices supported by Expo.
+ */
 export enum DeviceType {
+  /**
+   * An unrecognized device type.
+   */
   UNKNOWN = 0,
+  /**
+   * Mobile phone handsets, typically with a touch screen and held in one hand.
+   */
   PHONE,
+  /**
+   * Tablet computers, typically with a touch screen that is larger than a usual phone.
+   */
   TABLET,
+  /**
+   * Desktop or laptop computers, typically with a keyboard and mouse.
+   */
   DESKTOP,
+  /**
+   * Device with TV-based interfaces.
+   */
   TV,
 }

package/src/ExpoDevice.ts

@@ -1,2 +1,2 @@
-import { NativeModulesProxy } from 'expo-modules-core';
-export default NativeModulesProxy.ExpoDevice;
+import { requireNativeModule } from 'expo-modules-core';
+export default requireNativeModule('ExpoDevice');

package/android/src/main/java/expo/modules/device/DevicePackage.kt

@@ -1,11 +0,0 @@
-package expo.modules.device
-
-import android.content.Context
-import expo.modules.core.BasePackage
-import expo.modules.core.ExportedModule
-
-class DevicePackage : BasePackage() {
-  override fun createExportedModules(context: Context): List<ExportedModule> {
-    return listOf(DeviceModule(context))
-  }
-}