@symbiote-native/device 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,266 @@
+# @symbiote-native/device
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-device`](https://github.com/expo/expo/tree/main/packages/expo-device)
+— physical device information: brand/model/OS constants, uptime, max-memory,
+root/jailbreak detection, side-loading detection, and platform-feature queries — usable from
+**every** adapter, React, Vue, and Angular, not just React. Like
+[`@symbiote-native/local-auth`](../local-auth) and unlike this repo's stateful Expo wrapper
+([`@symbiote-native/sensors`](../sensors), an `EventEmitter` + live-subscription surface), every
+export here is either an eagerly-resolved constant or a one-shot async call with no per-instance
+state, so there is no hook/composable/service to wrap — the React, Vue, and Angular entry points
+are plain re-exports of the same `core`.
+
+## Install
+
+```bash
+npm install @symbiote-native/device
+```
+
+`expo-device` and `expo-modules-core` come along as regular dependencies, pinned to exact
+versions — never install either yourself, and never add the `expo` meta-package to your project
+(it bundles its own Metro/Babel pipeline, which conflicts with this project's own).
+
+## Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-device`'s native code is discovered by
+`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism — this needs wiring
+into the native host app **once**, covering this package and every other `expo-modules-core`
+package with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+
+Full mechanics live in the `symbiote-expo-native-module` project skill. Reference
+implementation: `examples/expo-react/ios/Podfile` and
+`examples/expo-react/android/app/src/main/java/com/canaryexpo/MainApplication.kt`.
+
+`expo-device` needs no runtime permission on either platform — every constant and function here
+reads plain system/build information, nothing gated by a permission prompt.
+
+## Shape
+
+```
+src/core/     Eager constants (isDevice, brand, manufacturer, modelId, modelName, designName,
+              productName, deviceType, deviceYearClass, totalMemory,
+              supportedCpuArchitectures, osName, osVersion, osBuildId, osInternalBuildId,
+              osBuildFingerprint, platformApiLevel, deviceName), plus getDeviceTypeAsync /
+              getUptimeAsync / getMaxMemoryAsync / isRootedExperimentalAsync /
+              isSideLoadingEnabledAsync / getPlatformFeaturesAsync / hasPlatformFeatureAsync,
+              and the DeviceType enum. native-module.ts resolves the native module via
+              expo-modules-core's requireNativeModule.
+src/react/    @symbiote-native/device/react   — export * from '../core'
+src/vue/      @symbiote-native/device/vue     — export * from '../core'
+src/angular/  @symbiote-native/device/angular — export * from '../core'
+```
+
+No per-adapter lifecycle wrapper exists because there's nothing to subscribe to or clean up —
+each adapter entry is a single-file re-export.
+
+## Use it
+
+```tsx
+// React
+import { useEffect, useState } from 'react';
+import { Text, View } from '@symbiote-native/react';
+import {
+  brand,
+  deviceName,
+  getMaxMemoryAsync,
+  getUptimeAsync,
+  isDevice,
+  modelName,
+  osName,
+  osVersion,
+} from '@symbiote-native/device/react';
+
+function DeviceScreen() {
+  const [uptime, setUptime] = useState<number | null>(null);
+  const [maxMemory, setMaxMemory] = useState<number | null>(null);
+
+  useEffect(() => {
+    getUptimeAsync().then(setUptime);
+    getMaxMemoryAsync().then(setMaxMemory);
+  }, []);
+
+  return (
+    <View>
+      <Text>{isDevice ? 'Real device' : 'Simulator/emulator'}</Text>
+      <Text>{`${brand ?? 'unknown'} ${modelName ?? ''}`}</Text>
+      <Text>{`${osName ?? 'unknown OS'} ${osVersion ?? ''}`}</Text>
+      <Text>{deviceName ?? 'unnamed device'}</Text>
+      <Text>{uptime === null ? 'checking uptime…' : `Uptime: ${uptime}ms`}</Text>
+      <Text>{maxMemory === null ? 'checking memory…' : `Max memory: ${maxMemory} bytes`}</Text>
+    </View>
+  );
+}
+```
+
+```vue
+<!-- Vue -->
+<script setup lang="ts">
+import { onMounted, ref } from 'vue';
+import { Text, View } from '@symbiote-native/vue';
+import {
+  brand,
+  deviceName,
+  getMaxMemoryAsync,
+  getUptimeAsync,
+  isDevice,
+  modelName,
+  osName,
+  osVersion,
+} from '@symbiote-native/device/vue';
+
+const uptime = ref<number | null>(null);
+const maxMemory = ref<number | null>(null);
+
+onMounted(() => {
+  void getUptimeAsync().then(value => (uptime.value = value));
+  void getMaxMemoryAsync().then(value => (maxMemory.value = value));
+});
+</script>
+
+<template>
+  <View>
+    <Text>{{ isDevice ? 'Real device' : 'Simulator/emulator' }}</Text>
+    <Text>{{ `${brand ?? 'unknown'} ${modelName ?? ''}` }}</Text>
+    <Text>{{ `${osName ?? 'unknown OS'} ${osVersion ?? ''}` }}</Text>
+    <Text>{{ deviceName ?? 'unnamed device' }}</Text>
+    <Text>{{ uptime === null ? 'checking uptime…' : `Uptime: ${uptime}ms` }}</Text>
+    <Text>{{ maxMemory === null ? 'checking memory…' : `Max memory: ${maxMemory} bytes` }}</Text>
+  </View>
+</template>
+```
+
+```ts
+// Angular
+import { Component, signal } from '@angular/core';
+import { Text, View } from '@symbiote-native/angular';
+import {
+  brand,
+  deviceName,
+  getMaxMemoryAsync,
+  getUptimeAsync,
+  isDevice,
+  modelName,
+  osName,
+  osVersion,
+} from '@symbiote-native/device/angular';
+
+@Component({
+  standalone: true,
+  imports: [Text, View],
+  template: `
+    <View>
+      <Text>{{ isDevice ? 'Real device' : 'Simulator/emulator' }}</Text>
+      <Text>{{ brand ?? 'unknown' }} {{ modelName ?? '' }}</Text>
+      <Text>{{ osName ?? 'unknown OS' }} {{ osVersion ?? '' }}</Text>
+      <Text>{{ deviceName ?? 'unnamed device' }}</Text>
+      <Text>{{ uptime() === null ? 'checking uptime…' : 'Uptime: ' + uptime() + 'ms' }}</Text>
+      <Text>{{ maxMemory() === null ? 'checking memory…' : 'Max memory: ' + maxMemory() + ' bytes' }}</Text>
+    </View>
+  `,
+})
+export class DeviceScreen {
+  readonly isDevice = isDevice;
+  readonly brand = brand;
+  readonly modelName = modelName;
+  readonly osName = osName;
+  readonly osVersion = osVersion;
+  readonly deviceName = deviceName;
+
+  readonly uptime = signal<number | null>(null);
+  readonly maxMemory = signal<number | null>(null);
+
+  constructor() {
+    getUptimeAsync().then(value => this.uptime.set(value));
+    getMaxMemoryAsync().then(value => this.maxMemory.set(value));
+  }
+}
+```
+
+There's no per-instance service to `inject()` in the Angular case — every constant/function is a
+plain export off the core package, read straight in the constructor or class-field initializer.
+These snippets are not yet demoed in a real canary screen — no `DeviceScreen.*` exists yet in
+`examples/expo-*` — so treat them as realistic reference code, not a trimmed-down copy of a
+running demo.
+
+## API
+
+Eagerly-resolved constants, plus a handful of one-shot async functions — no event stream, no
+per-instance state — so the React/Vue/Angular entry points above are plain re-exports of `core`
+with nothing adapter-specific to add.
+
+```ts
+// Constants — resolved once, at import time, straight off the native module:
+isDevice: boolean
+brand: string | null
+manufacturer: string | null
+modelId: string | null                    // iOS only
+modelName: string | null
+designName: string | null                 // Android only
+productName: string | null                // Android only
+deviceType: DeviceType | null
+deviceYearClass: number | null
+totalMemory: number | null
+supportedCpuArchitectures: string[] | null
+osName: string | null
+osVersion: string | null
+osBuildId: string | null
+osInternalBuildId: string | null
+osBuildFingerprint: string | null         // Android only
+platformApiLevel: number | null           // Android only
+deviceName: string | null
+
+// Functions:
+getDeviceTypeAsync(): Promise<DeviceType>
+getUptimeAsync(): Promise<number>                    // Android + iOS
+getMaxMemoryAsync(): Promise<number>                 // Android only; -1 sentinel normalized to Number.MAX_SAFE_INTEGER
+isRootedExperimentalAsync(): Promise<boolean>        // best-effort root/jailbreak check
+isSideLoadingEnabledAsync(): Promise<boolean>        // Android only
+getPlatformFeaturesAsync(): Promise<string[]>        // Android only; [] elsewhere, never throws
+hasPlatformFeatureAsync(feature: string): Promise<boolean> // Android only; false elsewhere, never throws
+```
+
+Plus `DeviceType` (`UNKNOWN`/`PHONE`/`TABLET`/`DESKTOP`/`TV`) — ported from upstream's
+`Device.types.ts`.
+
+```ts
+import { getDeviceTypeAsync, isDevice } from '@symbiote-native/device';
+// or the framework-scoped entry points — identical surface, re-exported verbatim:
+import { getDeviceTypeAsync } from '@symbiote-native/device/react';
+import { getDeviceTypeAsync } from '@symbiote-native/device/vue';
+import { getDeviceTypeAsync } from '@symbiote-native/device/angular';
+```
+
+## Notes
+
+- **Every function except `getPlatformFeaturesAsync`/`hasPlatformFeatureAsync` throws an
+  `UnavailabilityError` when the native method is missing.** Those two are the deliberate
+  exceptions — they resolve to `[]`/`false` instead, matching upstream, since a platform-feature
+  query on a platform with no such concept (iOS) is a normal "no" answer, not an error.
+- **`getMaxMemoryAsync`'s `-1` native sentinel means "no inherent limit"** and is normalized to
+  `Number.MAX_SAFE_INTEGER` before it reaches your code — you never see the raw `-1`.
+- **`isRootedExperimentalAsync` is a best-effort check, not a guarantee** — root/jailbreak
+  detection bypasses exist on both platforms; a `false` result does not prove the device is
+  unmodified.
+
+## Test it
+
+No Fabric/Descriptor angle at all — every export here is a pure constant or async-function
+surface, never a view or per-instance state. Tests inject a fake native-module object in place of
+the real `requireNativeModule` resolution (`src/core/device.test.ts`, `vitest`) — no
+`installFabric()`, no ViewConfig. Native rendering itself is verified on-device (see the parent
+[README](../../README.md) for the project's testing model).
+
+Native autolinking wiring for `expo-modules-core` packages is already done in the four Expo
+canary apps (`examples/expo-react`, `examples/expo-vue-sfc`, `examples/expo-vue-tsx`,
+`examples/expo-angular`) via `@symbiote-native/local-auth`/`@symbiote-native/sensors` — this
+package reuses that same wiring with zero further app-side changes, since
+`expo-modules-autolinking` discovers any `expo-modules-core` package already present in
+`node_modules`. A dedicated `DeviceScreen` demo has not been wired into those canaries yet.

package/build/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/device/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core';

package/build/core/device.d.ts

@@ -0,0 +1,138 @@
+import { DeviceType } from './types';
+/**
+ * `true` if the app is running on a real device and `false` if running in a simulator or
+ * emulator.
+ */
+export declare const isDevice: boolean;
+/**
+ * The device brand. The consumer-visible brand of the product/hardware.
+ * @example Device.brand; // Android: "google", "xiaomi"; iOS: "Apple"
+ */
+export declare const brand: string | null;
+/**
+ * The actual device manufacturer of the product or hardware. May be `null` if it cannot be
+ * determined.
+ */
+export declare const manufacturer: string | null;
+/**
+ * The internal model ID of the device — useful for programmatically identifying the type of
+ * device, not a human-friendly string.
+ * @platform ios
+ */
+export declare const modelId: string | null;
+/**
+ * The human-friendly name of the device model. May be `null` if it cannot be determined.
+ * @example Device.modelName; // Android: "Pixel 2"; iOS: "iPhone XS Max"
+ */
+export declare const modelName: string | null;
+/**
+ * The specific configuration or name of the industrial design — the device's name when it was
+ * designed during manufacturing into mass production. Corresponds to `Build.DEVICE`.
+ * @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`.
+ * @platform android
+ */
+export declare const productName: string | null;
+/**
+ * The type of the device as a {@link DeviceType} enum value.
+ */
+export declare const deviceType: DeviceType | null;
+/** The device year class (https://github.com/facebook/device-year-class) of this device. */
+export declare const deviceYearClass: number | null;
+/**
+ * The device's total memory, in bytes — the total memory accessible to the kernel, but not
+ * necessarily to a single app.
+ */
+export declare const totalMemory: number | null;
+/**
+ * A list of supported processor architecture versions. `null` if the supported architectures
+ * could not be determined.
+ */
+export declare const supportedCpuArchitectures: string[] | null;
+/**
+ * The name of the OS running on the device.
+ * @example Device.osName; // Android: "Android" or a build fingerprint string; iOS: "iOS"/"iPadOS"
+ */
+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.
+ */
+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`); on iOS to `kern.osversion`.
+ */
+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 it's the same value as {@link osBuildId}.
+ */
+export declare const osInternalBuildId: string | null;
+/**
+ * A string that uniquely identifies the build of the currently running system OS.
+ * @platform android
+ */
+export declare const osBuildFingerprint: string | null;
+/**
+ * The Android SDK version of the software currently running on this hardware device.
+ * @platform android
+ */
+export declare const platformApiLevel: number | null;
+/**
+ * The human-readable name of the device, which may be set by the device's user. `null` if the
+ * device name is unavailable.
+ */
+export declare const deviceName: string | null;
+/**
+ * Checks the type of the device as a {@link 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 it returns
+ * `DeviceType.UNKNOWN`.
+ */
+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.
+ * @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, `Number.MAX_SAFE_INTEGER` is returned instead of the native `-1` sentinel.
+ * @platform android
+ */
+export declare function getMaxMemoryAsync(): Promise<number>;
+/**
+ * Checks whether the device has been rooted (Android) or jailbroken (iOS). This is a best-effort
+ * check — root/jailbreak-detection bypasses exist on both platforms, so a `false` result is not
+ * a guarantee.
+ */
+export declare function isRootedExperimentalAsync(): Promise<boolean>;
+/**
+ * Returns whether applications can be installed for this user via the system's
+ * `ACTION_INSTALL_PACKAGE` mechanism, rather than through the OS's default app store. Requires
+ * the `REQUEST_INSTALL_PACKAGES` permission.
+ * @platform android
+ */
+export declare function isSideLoadingEnabledAsync(): Promise<boolean>;
+/**
+ * Gets a list of platform-specific feature names available on the system. Resolves to an empty
+ * array rather than throwing when the native method is absent (e.g. on iOS), matching upstream.
+ * @platform android
+ */
+export declare function getPlatformFeaturesAsync(): Promise<string[]>;
+/**
+ * Tells if the device has a specific system feature. Resolves to `false` rather than throwing
+ * when the native method is absent (e.g. on iOS), matching upstream.
+ * @platform android
+ */
+export declare function hasPlatformFeatureAsync(feature: string): Promise<boolean>;

package/build/core/device.js

@@ -0,0 +1,194 @@
+// Hand-ported from .vendors/expo/packages/expo-device/src/Device.ts (sdk-57). Every constant
+// below is resolved eagerly, once, at import time — matching upstream's own top-level `export
+// const` shape — from the native module's optional fields (native-module.ts), never imported
+// from expo-device's own JS.
+//
+// Deviation from upstream: upstream guards each constant with `ExpoDevice ? field : fallback`,
+// i.e. a truthiness check on the WHOLE module, because its own requireNativeModule call could in
+// principle resolve to a falsy value on some legacy/web target. Every sibling package in this
+// repo (local-auth, cellular, battery) instead resolves its native module unconditionally via
+// expo-modules-core's requireNativeModule, which throws rather than returning null/undefined —
+// so "the whole module is absent" already fails at import time here, same as every other
+// package. What upstream's ternary is actually doing field-by-field IS still real and worth
+// keeping: several constants are `undefined` on one platform by design (modelId is iOS-only;
+// designName/productName/osBuildFingerprint/platformApiLevel are Android-only), so each constant
+// below falls back with `??`, matching that per-field behavior without a redundant whole-module
+// check the rest of this codebase's convention doesn't otherwise use.
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoDevice } from './native-module';
+import { DeviceType } from './types';
+const NATIVE_MODULE_NAME = 'expo-device';
+const MAX_MEMORY_UNLIMITED_SENTINEL = -1;
+/**
+ * `true` if the app is running on a real device and `false` if running in a simulator or
+ * emulator.
+ */
+export const isDevice = expoDevice.isDevice ?? true;
+/**
+ * The device brand. The consumer-visible brand of the product/hardware.
+ * @example Device.brand; // Android: "google", "xiaomi"; iOS: "Apple"
+ */
+export const brand = expoDevice.brand ?? null;
+/**
+ * The actual device manufacturer of the product or hardware. May be `null` if it cannot be
+ * determined.
+ */
+export const manufacturer = expoDevice.manufacturer ?? null;
+/**
+ * The internal model ID of the device — useful for programmatically identifying the type of
+ * device, not a human-friendly string.
+ * @platform ios
+ */
+export const modelId = expoDevice.modelId ?? null;
+/**
+ * The human-friendly name of the device model. May be `null` if it cannot be determined.
+ * @example Device.modelName; // Android: "Pixel 2"; iOS: "iPhone XS Max"
+ */
+export const modelName = expoDevice.modelName ?? null;
+/**
+ * The specific configuration or name of the industrial design — the device's name when it was
+ * designed during manufacturing into mass production. Corresponds to `Build.DEVICE`.
+ * @platform android
+ */
+export const designName = expoDevice.designName ?? 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`.
+ * @platform android
+ */
+export const productName = expoDevice.productName ?? null;
+/**
+ * The type of the device as a {@link DeviceType} enum value.
+ */
+export const deviceType = expoDevice.deviceType ?? null;
+/** The device year class (https://github.com/facebook/device-year-class) of this device. */
+export const deviceYearClass = expoDevice.deviceYearClass ?? null;
+/**
+ * The device's total memory, in bytes — the total memory accessible to the kernel, but not
+ * necessarily to a single app.
+ */
+export const totalMemory = expoDevice.totalMemory ?? null;
+/**
+ * A list of supported processor architecture versions. `null` if the supported architectures
+ * could not be determined.
+ */
+export const supportedCpuArchitectures = expoDevice.supportedCpuArchitectures ?? null;
+/**
+ * The name of the OS running on the device.
+ * @example Device.osName; // Android: "Android" or a build fingerprint string; iOS: "iOS"/"iPadOS"
+ */
+export const osName = expoDevice.osName ?? null;
+/**
+ * The human-readable OS version string. Note that the version string may not always contain
+ * three numbers separated by dots.
+ */
+export const osVersion = 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`); on iOS to `kern.osversion`.
+ */
+export const osBuildId = expoDevice.osBuildId ?? null;
+/**
+ * The internal build ID of the OS running on the device. On Android this corresponds to
+ * `Build.ID`; on iOS it's the same value as {@link osBuildId}.
+ */
+export const osInternalBuildId = expoDevice.osInternalBuildId ?? null;
+/**
+ * A string that uniquely identifies the build of the currently running system OS.
+ * @platform android
+ */
+export const osBuildFingerprint = expoDevice.osBuildFingerprint ?? null;
+/**
+ * The Android SDK version of the software currently running on this hardware device.
+ * @platform android
+ */
+export const platformApiLevel = expoDevice.platformApiLevel ?? null;
+/**
+ * The human-readable name of the device, which may be set by the device's user. `null` if the
+ * device name is unavailable.
+ */
+export const deviceName = expoDevice.deviceName ?? null;
+/**
+ * Checks the type of the device as a {@link 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 it returns
+ * `DeviceType.UNKNOWN`.
+ */
+export async function getDeviceTypeAsync() {
+    if (!expoDevice.getDeviceTypeAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getDeviceTypeAsync');
+    }
+    return expoDevice.getDeviceTypeAsync();
+}
+/**
+ * Gets the uptime since the last reboot of the device, in milliseconds. Android devices do not
+ * count time spent in deep sleep.
+ * @platform android
+ * @platform ios
+ */
+export async function getUptimeAsync() {
+    if (!expoDevice.getUptimeAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getUptimeAsync');
+    }
+    return expoDevice.getUptimeAsync();
+}
+/**
+ * Returns the maximum amount of memory that the Java VM will attempt to use. If there is no
+ * inherent limit, `Number.MAX_SAFE_INTEGER` is returned instead of the native `-1` sentinel.
+ * @platform android
+ */
+export async function getMaxMemoryAsync() {
+    if (!expoDevice.getMaxMemoryAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getMaxMemoryAsync');
+    }
+    const maxMemory = await expoDevice.getMaxMemoryAsync();
+    return maxMemory === MAX_MEMORY_UNLIMITED_SENTINEL ? Number.MAX_SAFE_INTEGER : maxMemory;
+}
+/**
+ * Checks whether the device has been rooted (Android) or jailbroken (iOS). This is a best-effort
+ * check — root/jailbreak-detection bypasses exist on both platforms, so a `false` result is not
+ * a guarantee.
+ */
+export async function isRootedExperimentalAsync() {
+    if (!expoDevice.isRootedExperimentalAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'isRootedExperimentalAsync');
+    }
+    return expoDevice.isRootedExperimentalAsync();
+}
+/**
+ * Returns whether applications can be installed for this user via the system's
+ * `ACTION_INSTALL_PACKAGE` mechanism, rather than through the OS's default app store. Requires
+ * the `REQUEST_INSTALL_PACKAGES` permission.
+ * @platform android
+ */
+export async function isSideLoadingEnabledAsync() {
+    if (!expoDevice.isSideLoadingEnabledAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'isSideLoadingEnabledAsync');
+    }
+    return expoDevice.isSideLoadingEnabledAsync();
+}
+/**
+ * Gets a list of platform-specific feature names available on the system. Resolves to an empty
+ * array rather than throwing when the native method is absent (e.g. on iOS), matching upstream.
+ * @platform android
+ */
+export async function getPlatformFeaturesAsync() {
+    if (!expoDevice.getPlatformFeaturesAsync) {
+        return [];
+    }
+    return expoDevice.getPlatformFeaturesAsync();
+}
+/**
+ * Tells if the device has a specific system feature. Resolves to `false` rather than throwing
+ * when the native method is absent (e.g. on iOS), matching upstream.
+ * @platform android
+ */
+export async function hasPlatformFeatureAsync(feature) {
+    if (!expoDevice.hasPlatformFeatureAsync) {
+        return false;
+    }
+    return expoDevice.hasPlatformFeatureAsync(feature);
+}

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export { isDevice, brand, manufacturer, modelId, modelName, designName, productName, deviceType, deviceYearClass, totalMemory, supportedCpuArchitectures, osName, osVersion, osBuildId, osInternalBuildId, osBuildFingerprint, platformApiLevel, deviceName, getDeviceTypeAsync, getUptimeAsync, getMaxMemoryAsync, isRootedExperimentalAsync, isSideLoadingEnabledAsync, getPlatformFeaturesAsync, hasPlatformFeatureAsync, } from './device';
+export { DeviceType } from './types';

package/build/core/index.js

@@ -0,0 +1,2 @@
+export { isDevice, brand, manufacturer, modelId, modelName, designName, productName, deviceType, deviceYearClass, totalMemory, supportedCpuArchitectures, osName, osVersion, osBuildId, osInternalBuildId, osBuildFingerprint, platformApiLevel, deviceName, getDeviceTypeAsync, getUptimeAsync, getMaxMemoryAsync, isRootedExperimentalAsync, isSideLoadingEnabledAsync, getPlatformFeaturesAsync, hasPlatformFeatureAsync, } from './device';
+export { DeviceType } from './types';

package/build/core/native-module.d.ts

@@ -0,0 +1,29 @@
+import { DeviceType } from './types';
+export type INativeDeviceModule = {
+    isDevice?: boolean;
+    brand?: string | null;
+    manufacturer?: string | null;
+    modelId?: string | null;
+    modelName?: string | null;
+    designName?: string | null;
+    productName?: string | null;
+    deviceType?: DeviceType | null;
+    deviceYearClass?: number | null;
+    totalMemory?: number | null;
+    supportedCpuArchitectures?: string[] | null;
+    osName?: string | null;
+    osVersion?: string | null;
+    osBuildId?: string | null;
+    osInternalBuildId?: string | null;
+    osBuildFingerprint?: string | null;
+    platformApiLevel?: number | null;
+    deviceName?: string | null;
+    getDeviceTypeAsync?(): Promise<DeviceType>;
+    getUptimeAsync?(): Promise<number>;
+    getMaxMemoryAsync?(): Promise<number>;
+    isRootedExperimentalAsync?(): Promise<boolean>;
+    isSideLoadingEnabledAsync?(): Promise<boolean>;
+    getPlatformFeaturesAsync?(): Promise<string[]>;
+    hasPlatformFeatureAsync?(feature: string): Promise<boolean>;
+};
+export declare const expoDevice: INativeDeviceModule;

package/build/core/native-module.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+import { DeviceType } from './types';
+const EXPO_DEVICE_MODULE_NAME = 'ExpoDevice';
+export const expoDevice = requireNativeModule(EXPO_DEVICE_MODULE_NAME);