expo-device 4.3.0 → 5.1.0

package/CHANGELOG.md

@@ -10,6 +10,27 @@
 
 ### 💡 Others
 
+## 5.1.0 — 2022-12-30
+
+### 🎉 New features
+
+- Migrated Android codebase to use the new Expo modules API. ([#20118](https://github.com/expo/expo/pull/20118) by [@alanhughes](https://github.com/alanjhughes))
+- Native module on iOS is now written in Swift using the Sweet API. ([#19526](https://github.com/expo/expo/pull/19526) by [@fobos531](https://github.com/fobos531))
+
+## 5.0.0 — 2022-10-25
+
+### 🛠 Breaking changes
+
+- Bumped iOS deployment target to 13.0 and deprecated support for iOS 12. ([#18873](https://github.com/expo/expo/pull/18873) by [@tsapeta](https://github.com/tsapeta))
+
+### 🐛 Bug fixes
+
+- Fixed `<bluetooth_name> is only readable to apps with targetSdkVersion lower than or equal to: 31` error when the `targetSdkVersion` is set to 33. ([#19666](https://github.com/expo/expo/pull/19666) by [@kudo](https://github.com/kudo), [@kudo](https://github.com/kudo))
+
+### 💡 Others
+
+- Refactored inline emulator checks to use enhanced checking in `EmulatorUtilities.isRunningOnEmulator() `. ([#16177](https://github.com/expo/expo/pull/16177)) by [@kbrandwijk](https://github.com/kbrandwijk), [@keith-kurak](https://github.com/keith-kurak))
+
 ## 4.3.0 — 2022-07-07
 
 _This version does not introduce any user-facing changes._

package/README.md

@@ -4,7 +4,7 @@ Provides specific information about the device running the application.
 
 # API documentation
 
-- [Documentation for the main branch](https://github.com/expo/expo/blob/main/docs/pages/versions/unversioned/sdk/device.md)
+- [Documentation for the main branch](https://github.com/expo/expo/blob/main/docs/pages/versions/unversioned/sdk/device.mdx)
 - [Documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/device/)
 
 # Installation in managed Expo projects

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '4.3.0'
+version = '5.1.0'
 
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -74,7 +74,7 @@ android {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 31)
     versionCode 12
-    versionName '4.3.0'
+    versionName '5.1.0'
   }
   lintOptions {
     abortOnError false

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

@@ -1,11 +1,5 @@
 package expo.modules.device
 
-import expo.modules.core.ExportedModule
-import expo.modules.core.Promise
-import expo.modules.core.interfaces.ExpoMethod
-
-import com.facebook.device.yearclass.YearClass
-
 import android.app.ActivityManager
 import android.app.UiModeManager
 import android.content.Context
@@ -13,16 +7,20 @@ import android.content.res.Configuration
 import android.os.Build
 import android.os.SystemClock
 import android.provider.Settings
-import android.view.WindowManager
 import android.util.DisplayMetrics
-
+import android.view.WindowManager
+import com.facebook.device.yearclass.YearClass
+import expo.modules.core.utilities.EmulatorUtilities
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
 import java.io.File
 import kotlin.math.pow
 import kotlin.math.sqrt
 
 private const val NAME = "ExpoDevice"
 
-class DeviceModule(private val mContext: Context) : ExportedModule(mContext) {
+class DeviceModule : Module() {
   // Keep this enum in sync with JavaScript
   enum class DeviceType(val JSValue: Int) {
     UNKNOWN(0),
@@ -32,73 +30,57 @@ class DeviceModule(private val mContext: Context) : ExportedModule(mContext) {
     TV(4);
   }
 
-  override fun getName(): String {
-    return NAME
-  }
-
-  override fun getConstants(): Map<String, Any> = mapOf(
-    "isDevice" to (!isRunningOnGenymotion && !isRunningOnStockEmulator),
-    "brand" to Build.BRAND,
-    "manufacturer" to Build.MANUFACTURER,
-    "modelName" to Build.MODEL,
-    "designName" to Build.DEVICE,
-    "productName" to Build.DEVICE,
-    "deviceYearClass" to deviceYearClass,
-    "totalMemory" to run {
-      val memoryInfo = ActivityManager.MemoryInfo()
-      (mContext.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager).getMemoryInfo(memoryInfo)
-      memoryInfo.totalMem
-    },
-    "supportedCpuArchitectures" to run {
-      var supportedAbis = Build.SUPPORTED_ABIS
-      if (supportedAbis != null && supportedAbis.isEmpty()) {
-        supportedAbis = null
-      }
-      supportedAbis
-    },
-    "osName" to systemName,
-    "osVersion" to Build.VERSION.RELEASE,
-    "osBuildId" to Build.DISPLAY,
-    "osInternalBuildId" to Build.ID,
-    "osBuildFingerprint" to Build.FINGERPRINT,
-    "platformApiLevel" to Build.VERSION.SDK_INT,
-    "deviceName" to Settings.Secure.getString(mContext.contentResolver, "bluetooth_name")
-  )
-
-  private val deviceYearClass: Int
-    get() = YearClass.get(mContext)
-
-  private val systemName: String
-    get() {
-      return if (Build.VERSION.SDK_INT < 23) {
-        "Android"
-      } else {
-        Build.VERSION.BASE_OS.takeIf { it.isNotEmpty() } ?: "Android"
-      }
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoDevice")
+
+    Constants {
+      return@Constants mapOf(
+        "isDevice" to !isRunningOnEmulator,
+        "brand" to Build.BRAND,
+        "manufacturer" to Build.MANUFACTURER,
+        "modelName" to Build.MODEL,
+        "designName" to Build.DEVICE,
+        "productName" to Build.DEVICE,
+        "deviceYearClass" to deviceYearClass,
+        "totalMemory" to run {
+          val memoryInfo = ActivityManager.MemoryInfo()
+          (context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager).getMemoryInfo(memoryInfo)
+          memoryInfo.totalMem
+        },
+        "supportedCpuArchitectures" to Build.SUPPORTED_ABIS?.takeIf { it.isNotEmpty() },
+        "osName" to systemName,
+        "osVersion" to Build.VERSION.RELEASE,
+        "osBuildId" to Build.DISPLAY,
+        "osInternalBuildId" to Build.ID,
+        "osBuildFingerprint" to Build.FINGERPRINT,
+        "platformApiLevel" to Build.VERSION.SDK_INT,
+        "deviceName" to if (Build.VERSION.SDK_INT <= 31)
+          Settings.Secure.getString(context.contentResolver, "bluetooth_name")
+        else
+          Settings.Global.getString(context.contentResolver, Settings.Global.DEVICE_NAME)
+      )
     }
 
-  @ExpoMethod
-  fun getDeviceTypeAsync(promise: Promise) {
-    promise.resolve(getDeviceType(mContext).JSValue)
-  }
+    AsyncFunction("getDeviceTypeAsync") {
+      return@AsyncFunction getDeviceType(context).JSValue
+    }
 
-  @ExpoMethod
-  fun getUptimeAsync(promise: Promise) {
-    promise.resolve(SystemClock.uptimeMillis().toDouble())
-  }
+    AsyncFunction("getUptimeAsync") {
+      return@AsyncFunction SystemClock.uptimeMillis().toDouble()
+    }
 
-  @ExpoMethod
-  fun getMaxMemoryAsync(promise: Promise) {
-    val maxMemory = Runtime.getRuntime().maxMemory()
-    promise.resolve(if (maxMemory != Long.MAX_VALUE) maxMemory.toDouble() else -1)
-  }
+    AsyncFunction("getMaxMemoryAsync") {
+      val maxMemory = Runtime.getRuntime().maxMemory()
+      return@AsyncFunction if (maxMemory != Long.MAX_VALUE) maxMemory.toDouble() else -1
+    }
 
-  @ExpoMethod
-  fun isRootedExperimentalAsync(promise: Promise) {
-    var isRooted = false
-    val isDevice = !isRunningOnGenymotion && !isRunningOnStockEmulator
+    AsyncFunction("isRootedExperimentalAsync") {
+      val isRooted: Boolean
+      val isDevice = !isRunningOnEmulator
 
-    try {
       val buildTags = Build.TAGS
       isRooted = if (isDevice && buildTags != null && buildTags.contains("test-keys")) {
         true
@@ -109,52 +91,49 @@ class DeviceModule(private val mContext: Context) : ExportedModule(mContext) {
           isDevice && File("/system/xbin/su").exists()
         }
       }
-    } catch (se: SecurityException) {
-      promise.reject(
-        "ERR_DEVICE_ROOT_DETECTION",
-        "Could not access the file system to determine if the device is rooted.",
-        se
-      )
-      return
+
+      return@AsyncFunction isRooted
     }
 
-    promise.resolve(isRooted)
-  }
+    AsyncFunction("isSideLoadingEnabledAsync") {
+      return@AsyncFunction if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+        Settings.Global.getInt(
+          context.applicationContext.contentResolver,
+          Settings.Global.INSTALL_NON_MARKET_APPS,
+          0
+        ) == 1
+      } else {
+        context.applicationContext.packageManager.canRequestPackageInstalls()
+      }
+    }
 
-  @ExpoMethod
-  fun isSideLoadingEnabledAsync(promise: Promise) {
-    val enabled: Boolean = if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-      Settings.Global.getInt(
-        mContext.applicationContext.contentResolver,
-        Settings.Global.INSTALL_NON_MARKET_APPS,
-        0
-      ) == 1
-    } else {
-      mContext.applicationContext.packageManager.canRequestPackageInstalls()
+    AsyncFunction("getPlatformFeaturesAsync") {
+      val allFeatures = context.applicationContext.packageManager.systemAvailableFeatures
+      return@AsyncFunction allFeatures.filterNotNull().map { it.name }
     }
 
-    promise.resolve(enabled)
+    AsyncFunction("hasPlatformFeatureAsync") { feature: String ->
+      return@AsyncFunction context.applicationContext.packageManager.hasSystemFeature(feature)
+    }
   }
 
-  @ExpoMethod
-  fun getPlatformFeaturesAsync(promise: Promise) {
-    val allFeatures = mContext.applicationContext.packageManager.systemAvailableFeatures
-    val featureList = allFeatures.filterNotNull().map { it.name }
-    promise.resolve(featureList)
-  }
+  private val deviceYearClass: Int
+    get() = YearClass.get(context)
 
-  @ExpoMethod
-  fun hasPlatformFeatureAsync(feature: String, promise: Promise) {
-    promise.resolve(mContext.applicationContext.packageManager.hasSystemFeature(feature))
-  }
+  private val systemName: String
+    get() {
+      return if (Build.VERSION.SDK_INT < 23) {
+        "Android"
+      } else {
+        Build.VERSION.BASE_OS.takeIf { it.isNotEmpty() } ?: "Android"
+      }
+    }
 
   companion object {
     private val TAG = DeviceModule::class.java.simpleName
 
-    private val isRunningOnGenymotion: Boolean
-      get() = Build.FINGERPRINT.contains("vbox")
-    private val isRunningOnStockEmulator: Boolean
-      get() = Build.FINGERPRINT.contains("generic")
+    private val isRunningOnEmulator: Boolean
+      get() = EmulatorUtilities.isRunningOnEmulator()
 
     private fun getDeviceType(context: Context): DeviceType {
       // Detect TVs via UI mode (Android TVs) or system features (Fire TV).
@@ -168,7 +147,8 @@ class DeviceModule(private val mContext: Context) : ExportedModule(mContext) {
       }
 
       // Find the current window manager, if none is found we can't measure the device physical size.
-      val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager? ?: return DeviceType.UNKNOWN
+      val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager?
+        ?: return DeviceType.UNKNOWN
 
       // Get display metrics to see if we can differentiate phones and tablets.
       val metrics = DisplayMetrics()
@@ -178,7 +158,7 @@ class DeviceModule(private val mContext: Context) : ExportedModule(mContext) {
       val widthInches = metrics.widthPixels / metrics.xdpi.toDouble()
       val heightInches = metrics.heightPixels / metrics.ydpi.toDouble()
       val diagonalSizeInches = sqrt(widthInches.pow(2.0) + heightInches.pow(2.0))
-      return if (diagonalSizeInches >= 3.0 && diagonalSizeInches <= 6.9) {
+      return if (diagonalSizeInches in 3.0..6.9) {
         // Devices in a sane range for phones are considered to be phones.
         DeviceType.PHONE
       } else if (diagonalSizeInches > 6.9 && diagonalSizeInches <= 18.0) {

package/build/Device.d.ts

@@ -1,27 +1,277 @@
 import { DeviceType } from './Device.types';
 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 declare const isDevice: boolean;
+/**
+ * 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 declare const brand: string | 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 declare const manufacturer: string | 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 declare const modelId: any;
+/**
+ * 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 declare const modelName: string | 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 declare const designName: string | 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 declare const productName: string | null;
+/**
+ * The [device year class](https://github.com/facebook/device-year-class) of this device. On web, this value is always `null`.
+ */
 export declare const deviceYearClass: number | 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 declare const totalMemory: number | 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 declare const supportedCpuArchitectures: string[] | 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 declare const osName: string | 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 declare const osVersion: string | 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 declare const osBuildId: string | 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 declare const osInternalBuildId: string | 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 declare const osBuildFingerprint: string | 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 declare const platformApiLevel: number | 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 declare const deviceName: string | 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 declare function getDeviceTypeAsync(): Promise<DeviceType>;
+/**
+ * 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 declare function getUptimeAsync(): Promise<number>;
+/**
+ * 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 declare function getMaxMemoryAsync(): Promise<number>;
+/**
+ * > **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 declare function isRootedExperimentalAsync(): Promise<boolean>;
+/**
+ * **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 declare function isSideLoadingEnabledAsync(): Promise<boolean>;
+/**
+ * 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 declare function getPlatformFeaturesAsync(): Promise<string[]>;
+/**
+ * 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 declare function hasPlatformFeatureAsync(feature: string): Promise<boolean>;
 //# sourceMappingURL=Device.d.ts.map

package/build/Device.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Device.d.ts","sourceRoot":"","sources":["../src/Device.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAG5C,OAAO,EAAE,UAAU,EAAE,CAAC;AAEtB,eAAO,MAAM,QAAQ,EAAE,OAAiD,CAAC;AACzE,eAAO,MAAM,KAAK,EAAE,MAAM,GAAG,IAA2C,CAAC;AACzE,eAAO,MAAM,YAAY,EAAE,MAAM,GAAG,IAAkD,CAAC;AACvF,eAAO,MAAM,OAAO,KAAiD,CAAC;AACtE,eAAO,MAAM,SAAS,EAAE,MAAM,GAAG,IAA+C,CAAC;AACjF,eAAO,MAAM,UAAU,EAAE,MAAM,GAAG,IAAwD,CAAC;AAC3F,eAAO,MAAM,WAAW,EAAE,MAAM,GAAG,IAAyD,CAAC;AAC7F,eAAO,MAAM,eAAe,EAAE,MAAM,GAAG,IAAqD,CAAC;AAC7F,eAAO,MAAM,WAAW,EAAE,MAAM,GAAG,IAAiD,CAAC;AACrF,eAAO,MAAM,yBAAyB,EAAE,MAAM,EAAE,GAAG,IAE3C,CAAC;AACT,eAAO,MAAM,MAAM,EAAE,MAAM,GAAG,IAA4C,CAAC;AAC3E,eAAO,MAAM,SAAS,EAAE,MAAM,GAAG,IAA+C,CAAC;AACjF,eAAO,MAAM,SAAS,EAAE,MAAM,GAAG,IAA+C,CAAC;AACjF,eAAO,MAAM,iBAAiB,EAAE,MAAM,GAAG,IAAuD,CAAC;AACjG,eAAO,MAAM,kBAAkB,EAAE,MAAM,GAAG,IAElC,CAAC;AACT,eAAO,MAAM,gBAAgB,EAAE,MAAM,GAAG,IAEhC,CAAC;AACT,eAAO,MAAM,UAAU,EAAE,MAAM,GAAG,IAAgD,CAAC;AAEnF,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,UAAU,CAAC,CAK9D;AAED,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAKtD;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,CASzD;AAED,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,OAAO,CAAC,CAKlE;AAED,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,OAAO,CAAC,CAKlE;AAED,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAKlE;AAED,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAK/E"}
+{"version":3,"file":"Device.d.ts","sourceRoot":"","sources":["../src/Device.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAG5C,OAAO,EAAE,UAAU,EAAE,CAAC;AAEtB;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,OAAiD,CAAC;AAEzE;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,EAAE,MAAM,GAAG,IAA2C,CAAC;AAEzE;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,GAAG,IAAkD,CAAC;AAEvF;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,KAAiD,CAAC;AAEtE;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,GAAG,IAA+C,CAAC;AAEjF;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,GAAG,IAAwD,CAAC;AAE3F;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,GAAG,IAAyD,CAAC;AAE7F;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,GAAG,IAAqD,CAAC;AAE7F;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,GAAG,IAAiD,CAAC;AAErF;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,EAAE,GAAG,IAE3C,CAAC;AAET;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,GAAG,IAA4C,CAAC;AAE3E;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,GAAG,IAA+C,CAAC;AAEjF;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,GAAG,IAA+C,CAAC;AAEjF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,GAAG,IAAuD,CAAC;AAEjG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,GAAG,IAElC,CAAC;AAET;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,GAAG,IAEhC,CAAC;AAET;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,GAAG,IAAgD,CAAC;AAEnF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,UAAU,CAAC,CAK9D;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAKtD;AAED;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,CASzD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,OAAO,CAAC,CAKlE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,OAAO,CAAC,CAKlE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAKlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAK/E"}