@symbiote-native/device 0.0.1

package/src/core/device.test.ts

@@ -0,0 +1,202 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_DEVICE = {
+  isDevice: true,
+  brand: 'Apple',
+  manufacturer: 'Apple',
+  modelId: 'iPhone14,2',
+  modelName: 'iPhone 13 Pro',
+  designName: null,
+  productName: null,
+  deviceType: 1,
+  deviceYearClass: 2_021,
+  totalMemory: 6_442_450_944,
+  supportedCpuArchitectures: ['arm64'],
+  osName: 'iOS',
+  osVersion: '17.4',
+  osBuildId: '21E219',
+  osInternalBuildId: '21E219',
+  osBuildFingerprint: null,
+  platformApiLevel: null,
+  deviceName: "Andrey's iPhone",
+  getDeviceTypeAsync: vi.fn(async () => 1),
+  getUptimeAsync: vi.fn(async () => 4_371_054),
+  getMaxMemoryAsync: vi.fn(async () => 402_653_184),
+  isRootedExperimentalAsync: vi.fn(async () => false),
+  isSideLoadingEnabledAsync: vi.fn(async () => false),
+  getPlatformFeaturesAsync: vi.fn(async () => ['android.hardware.sensor.accelerometer']),
+  hasPlatformFeatureAsync: vi.fn(async () => true),
+};
+
+// The real ExpoDevice native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of expo-modules-core's runtime resolution, the same
+// pattern packages/local-auth/src/core/local-authentication.test.ts uses.
+vi.mock('./native-module', () => ({
+  expoDevice: FAKE_NATIVE_DEVICE,
+}));
+
+// expo-modules-core's real entry transitively imports 'react-native' for Platform/
+// TurboModuleRegistry, whose Flow-typed source Vitest's Oxc transform can't parse — same fake
+// packages/local-auth/src/core/local-authentication.test.ts uses.
+vi.mock('expo-modules-core', () => ({
+  UnavailabilityError: class UnavailabilityError extends Error {
+    constructor(moduleName: string, propertyName: string) {
+      super(`${propertyName} is not available on ${moduleName}`);
+    }
+  },
+}));
+
+const {
+  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,
+} = await import('./device');
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('eagerly resolved constants', () => {
+  it('read straight off the native module at import time', () => {
+    expect(isDevice).toBe(true);
+    expect(brand).toBe('Apple');
+    expect(manufacturer).toBe('Apple');
+    expect(modelId).toBe('iPhone14,2');
+    expect(modelName).toBe('iPhone 13 Pro');
+    expect(designName).toBeNull();
+    expect(productName).toBeNull();
+    expect(deviceType).toBe(1);
+    expect(deviceYearClass).toBe(2_021);
+    expect(totalMemory).toBe(6_442_450_944);
+    expect(supportedCpuArchitectures).toEqual(['arm64']);
+    expect(osName).toBe('iOS');
+    expect(osVersion).toBe('17.4');
+    expect(osBuildId).toBe('21E219');
+    expect(osInternalBuildId).toBe('21E219');
+    expect(osBuildFingerprint).toBeNull();
+    expect(platformApiLevel).toBeNull();
+    expect(deviceName).toBe("Andrey's iPhone");
+  });
+});
+
+describe('getDeviceTypeAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(getDeviceTypeAsync()).resolves.toBe(1);
+  });
+
+  it('throws an UnavailabilityError-shaped error when the native method is absent', async () => {
+    const { getDeviceTypeAsync: native } = FAKE_NATIVE_DEVICE;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_DEVICE.getDeviceTypeAsync = undefined;
+
+    await expect(getDeviceTypeAsync()).rejects.toThrow(
+      'getDeviceTypeAsync is not available on expo-device',
+    );
+
+    FAKE_NATIVE_DEVICE.getDeviceTypeAsync = native;
+  });
+});
+
+describe('getUptimeAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(getUptimeAsync()).resolves.toBe(4_371_054);
+  });
+});
+
+describe('getMaxMemoryAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(getMaxMemoryAsync()).resolves.toBe(402_653_184);
+  });
+
+  it('normalizes the -1 unlimited sentinel to Number.MAX_SAFE_INTEGER', async () => {
+    const { getMaxMemoryAsync: native } = FAKE_NATIVE_DEVICE;
+    FAKE_NATIVE_DEVICE.getMaxMemoryAsync = vi.fn(async () => -1);
+
+    await expect(getMaxMemoryAsync()).resolves.toBe(Number.MAX_SAFE_INTEGER);
+
+    FAKE_NATIVE_DEVICE.getMaxMemoryAsync = native;
+  });
+
+  it('throws an UnavailabilityError-shaped error when the native method is absent', async () => {
+    const { getMaxMemoryAsync: native } = FAKE_NATIVE_DEVICE;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_DEVICE.getMaxMemoryAsync = undefined;
+
+    await expect(getMaxMemoryAsync()).rejects.toThrow(
+      'getMaxMemoryAsync is not available on expo-device',
+    );
+
+    FAKE_NATIVE_DEVICE.getMaxMemoryAsync = native;
+  });
+});
+
+describe('isRootedExperimentalAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(isRootedExperimentalAsync()).resolves.toBe(false);
+  });
+});
+
+describe('isSideLoadingEnabledAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(isSideLoadingEnabledAsync()).resolves.toBe(false);
+  });
+});
+
+describe('getPlatformFeaturesAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(getPlatformFeaturesAsync()).resolves.toEqual([
+      'android.hardware.sensor.accelerometer',
+    ]);
+  });
+
+  it('resolves an empty array instead of throwing when the native method is absent', async () => {
+    const { getPlatformFeaturesAsync: native } = FAKE_NATIVE_DEVICE;
+    // @ts-expect-error -- simulating iOS, where getPlatformFeaturesAsync has no native implementation
+    FAKE_NATIVE_DEVICE.getPlatformFeaturesAsync = undefined;
+
+    await expect(getPlatformFeaturesAsync()).resolves.toEqual([]);
+
+    FAKE_NATIVE_DEVICE.getPlatformFeaturesAsync = native;
+  });
+});
+
+describe('hasPlatformFeatureAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(hasPlatformFeatureAsync('android.hardware.sensor.accelerometer')).resolves.toBe(
+      true,
+    );
+  });
+
+  it('resolves false instead of throwing when the native method is absent', async () => {
+    const { hasPlatformFeatureAsync: native } = FAKE_NATIVE_DEVICE;
+    // @ts-expect-error -- simulating iOS, where hasPlatformFeatureAsync has no native implementation
+    FAKE_NATIVE_DEVICE.hasPlatformFeatureAsync = undefined;
+
+    await expect(hasPlatformFeatureAsync('any')).resolves.toBe(false);
+
+    FAKE_NATIVE_DEVICE.hasPlatformFeatureAsync = native;
+  });
+});

package/src/core/device.ts

@@ -0,0 +1,222 @@
+// 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: boolean = 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: string | null = expoDevice.brand ?? null;
+
+/**
+ * The actual device manufacturer of the product or hardware. May be `null` if it cannot be
+ * determined.
+ */
+export const manufacturer: string | null = 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: string | null = 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: string | null = 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: string | null = 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: string | null = expoDevice.productName ?? null;
+
+/**
+ * The type of the device as a {@link DeviceType} enum value.
+ */
+export const deviceType: DeviceType | null = expoDevice.deviceType ?? null;
+
+/** The device year class (https://github.com/facebook/device-year-class) of this device. */
+export const deviceYearClass: number | null = 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: number | null = expoDevice.totalMemory ?? null;
+
+/**
+ * A list of supported processor architecture versions. `null` if the supported architectures
+ * could not be determined.
+ */
+export const supportedCpuArchitectures: string[] | null =
+  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: string | null = 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: string | null = 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: string | null = 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: string | null = expoDevice.osInternalBuildId ?? null;
+
+/**
+ * A string that uniquely identifies the build of the currently running system OS.
+ * @platform android
+ */
+export const osBuildFingerprint: string | null = expoDevice.osBuildFingerprint ?? null;
+
+/**
+ * The Android SDK version of the software currently running on this hardware device.
+ * @platform android
+ */
+export const platformApiLevel: number | null = 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: string | null = 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(): Promise<DeviceType> {
+  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(): Promise<number> {
+  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(): Promise<number> {
+  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(): Promise<boolean> {
+  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(): Promise<boolean> {
+  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(): Promise<string[]> {
+  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: string): Promise<boolean> {
+  if (!expoDevice.hasPlatformFeatureAsync) {
+    return false;
+  }
+  return expoDevice.hasPlatformFeatureAsync(feature);
+}

package/src/core/index.ts

@@ -0,0 +1,28 @@
+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/src/core/native-module.ts

@@ -0,0 +1,42 @@
+import { requireNativeModule } from 'expo-modules-core';
+import { DeviceType } from './types';
+
+const EXPO_DEVICE_MODULE_NAME = 'ExpoDevice';
+
+// Constants are optional fields (not just the async methods) because several of them are
+// genuinely absent on one platform — modelId is iOS-only, designName/productName/
+// osBuildFingerprint/platformApiLevel are Android-only — so the native module itself may simply
+// never populate that field rather than the whole module being unavailable. Each async method is
+// optional for the same reason every sibling package's native module type is (local-auth,
+// cellular, battery): each call site in device.ts checks for the method's presence itself and
+// throws an UnavailabilityError, matching upstream's own per-platform capability checks rather
+// than assuming the native module implements the whole surface.
+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 const expoDevice = requireNativeModule<INativeDeviceModule>(EXPO_DEVICE_MODULE_NAME);

package/src/core/types.ts

@@ -0,0 +1,17 @@
+// Hand-ported from .vendors/expo/packages/expo-device/src/Device.types.ts (sdk-57). The enum
+// itself carries no platform-specific logic (unlike local-auth's SecurityLevel.BIOMETRIC alias),
+// so it's a verbatim port with no expo-modules-core dependency at all.
+
+/** The type of device the app is currently running on. */
+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/react/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/device/react: the React entry over the framework-agnostic core. Upstream
+// ships eager constants and free async functions, no per-instance state and no event stream
+// (unlike @symbiote-native/sensors) — there is nothing for a hook to wrap, so this is a plain
+// re-export, mirroring how @symbiote-native/local-auth's React entry passes its own free
+// functions through untouched.
+export * from '../core';

package/src/vue/index.ts

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