react-native-app-device-info 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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,401 @@
+# react-native-app-device-info
+
+Minimal, fast, synchronous app and device information for React Native.
+
+Every value is read from native constants that are computed once when the app
+starts. From JavaScript there is no `Promise`, no `await`, and no bridge
+round-trip. Every getter is a plain synchronous function call. The library
+works on iOS and Android, on both the Old and the New Architecture.
+
+```ts
+import AppDeviceInfo from 'react-native-app-device-info';
+
+AppDeviceInfo.getVersion();     // "1.2.3"
+AppDeviceInfo.getBuildNumber(); // "42"
+AppDeviceInfo.getUniqueId();    // a stable id for this device
+```
+
+---
+
+## Table of contents
+
+- [Why this library](#why-this-library)
+- [Requirements](#requirements)
+- [Installation](#installation)
+  - [iOS](#ios)
+  - [Android](#android)
+  - [Expo](#expo)
+- [Quick start](#quick-start)
+- [API reference](#api-reference)
+  - [App information](#app-information)
+  - [Device and OS information](#device-and-os-information)
+  - [Install information](#install-information)
+  - [Get everything at once](#get-everything-at-once)
+- [Field notes](#field-notes)
+  - [getUniqueId](#getuniqueid)
+  - [getBundleId vs getBaseBundleId](#getbundleid-vs-getbasebundleid)
+  - [getInstallerSource](#getinstallersource)
+  - [Install and update times](#install-and-update-times)
+  - [isEmulator](#isemulator)
+- [How it works](#how-it-works)
+- [TypeScript](#typescript)
+- [Platform support matrix](#platform-support-matrix)
+- [Troubleshooting](#troubleshooting)
+- [License](#license)
+
+---
+
+## Why this library
+
+- **Small.** One native module, about twenty getters, zero runtime
+  dependencies.
+- **Fast.** Values are exposed as native constants, so reading them is just a
+  property access. There is no message sent over the bridge and no startup
+  penalty.
+- **Simple.** Synchronous getters. No callbacks, no promises, nothing to wait
+  for.
+- **Consistent.** The same API and the same return types on iOS and Android.
+- **Future proof.** Identical behaviour on the legacy bridge and the New
+  Architecture (bridgeless / TurboModules interop).
+
+---
+
+## Requirements
+
+- React Native 0.64 or newer (Old or New Architecture).
+- iOS 12.0 or newer.
+- Android API level 21 (Android 5.0) or newer.
+
+---
+
+## Installation
+
+```sh
+npm install react-native-app-device-info
+```
+
+or
+
+```sh
+yarn add react-native-app-device-info
+```
+
+This package contains native code, so you must rebuild the app after installing
+it. A Fast Refresh / Metro reload is not enough.
+
+### iOS
+
+Install the CocoaPods dependency, then rebuild:
+
+```sh
+cd ios && pod install && cd ..
+npx react-native run-ios
+```
+
+### Android
+
+Autolinking handles everything. Just rebuild the app:
+
+```sh
+npx react-native run-android
+```
+
+### Expo
+
+This is a native module, so it does not run in Expo Go. Use a development
+build:
+
+```sh
+npx expo install react-native-app-device-info
+npx expo prebuild
+npx expo run:ios     # or: npx expo run:android
+```
+
+---
+
+## Quick start
+
+You can import the default object and call methods on it:
+
+```ts
+import AppDeviceInfo from 'react-native-app-device-info';
+
+console.log(AppDeviceInfo.getReadableVersion()); // "1.2.3 (42)"
+console.log(AppDeviceInfo.getOsName(), AppDeviceInfo.getOsVersion()); // "iOS" "17.4"
+console.log(AppDeviceInfo.getUniqueId());
+```
+
+Or import only the functions you need:
+
+```ts
+import { getVersion, getBuildNumber, getInfo } from 'react-native-app-device-info';
+
+const version = getVersion();
+const build = getBuildNumber();
+const everything = getInfo();
+```
+
+Both styles are equivalent and fully typed.
+
+---
+
+## API reference
+
+Every function is synchronous and returns immediately. The tables show the
+return type and the native source on each platform.
+
+### App information
+
+| Function               | Returns  | iOS                          | Android                                              |
+| ---------------------- | -------- | ---------------------------- | ---------------------------------------------------- |
+| `getVersion()`         | `string` | `CFBundleShortVersionString` | `versionName`                                        |
+| `getBuildNumber()`     | `string` | `CFBundleVersion`            | `versionCode`                                        |
+| `getBundleId()`        | `string` | `bundleIdentifier`           | `packageName` (runtime applicationId, incl. suffix)  |
+| `getBaseBundleId()`    | `string` | bundle id without suffix     | applicationId without suffix                         |
+| `getAppName()`         | `string` | display name                 | application label                                    |
+| `getReadableVersion()` | `string` | `"1.2.3 (42)"`               | `"1.2.3 (42)"`                                        |
+
+`getVersion()` is the human-facing version (the "version name" / "build name").
+`getBuildNumber()` is the internal incrementing number (the "build number" /
+"version code").
+
+### Device and OS information
+
+| Function            | Returns              | iOS                   | Android                  |
+| ------------------- | -------------------- | --------------------- | ------------------------ |
+| `getOsName()`       | `string`             | `"iOS"`               | `"Android"`              |
+| `getOsVersion()`    | `string`             | `systemVersion`       | `Build.VERSION.RELEASE`  |
+| `getDeviceType()`   | `'ios' \| 'android'` | `"ios"`               | `"android"`              |
+| `getDeviceModel()`  | `string`             | e.g. `"iPhone15,2"`   | `Build.MODEL`            |
+| `getDeviceBrand()`  | `string`             | `"Apple"`             | `Build.MANUFACTURER`     |
+| `isTablet()`        | `boolean`            | iPad?                 | large screen?            |
+| `getUniqueId()`     | `string`             | `identifierForVendor` | `Settings.Secure.ANDROID_ID` |
+| `isEmulator()`      | `boolean`            | running on simulator? | running on emulator?     |
+| `getDeviceLocale()` | `string`             | e.g. `"en-US"`        | e.g. `"en-US"`           |
+| `getTimezone()`     | `string`             | e.g. `"America/New_York"` | e.g. `"America/New_York"` |
+| `getApiLevel()`     | `number`             | `0` (not applicable)  | `Build.VERSION.SDK_INT`  |
+
+### Install information
+
+| Function                | Returns  | iOS                                        | Android                                                            |
+| ----------------------- | -------- | ------------------------------------------ | ----------------------------------------------------------------- |
+| `getInstallerSource()`  | `string` | `"AppStore"` / `"TestFlight"` / `"Other"`  | installing package, e.g. `"com.android.vending"`, or `""`         |
+| `getFirstInstallTime()` | `number` | epoch milliseconds (heuristic)             | epoch milliseconds (exact)                                        |
+| `getLastUpdateTime()`   | `number` | epoch milliseconds (heuristic)             | epoch milliseconds (exact)                                        |
+
+Times are epoch **milliseconds**. Wrap a value with `new Date(ms)` to get a
+`Date`. A value of `0` means the time could not be determined.
+
+### Get everything at once
+
+`getInfo()` returns every value in a single object. The result is computed once
+and cached, so calling it repeatedly is free.
+
+```ts
+import { getInfo } from 'react-native-app-device-info';
+
+const info = getInfo();
+```
+
+The returned object has this exact shape:
+
+```ts
+interface AppDeviceInfoConstants {
+  // App
+  appVersion: string;       // "1.2.3"
+  buildNumber: string;      // "42"
+  bundleId: string;         // "com.acme.app"
+  appName: string;          // "Acme"
+
+  // Device and OS
+  osName: string;           // "iOS" | "Android"
+  osVersion: string;        // "17.4"
+  deviceType: 'ios' | 'android';
+  deviceModel: string;      // "iPhone15,2" | "Pixel 8"
+  deviceBrand: string;      // "Apple" | "Google"
+  isTablet: boolean;
+  deviceId: string;         // stable per-device id
+  isEmulator: boolean;
+  deviceLocale: string;     // "en-US"
+  timezone: string;         // "America/New_York"
+  apiLevel: number;         // 34 on Android, 0 on iOS
+
+  // Install
+  installerSource: string;  // "AppStore" | "com.android.vending" | ...
+  firstInstallTime: number; // epoch ms, 0 if unknown
+  lastUpdateTime: number;   // epoch ms, 0 if unknown
+}
+```
+
+Note that `getInfo().appVersion` is the value behind `getVersion()`,
+`getInfo().buildNumber` is the value behind `getBuildNumber()`, and so on. The
+individual getters are thin convenience wrappers around this object.
+
+---
+
+## Field notes
+
+This section explains the values that need context so you choose the right one
+and know exactly what it guarantees.
+
+### getUniqueId
+
+A stable id for the device that persists across app launches and app updates.
+
+- **iOS** returns `identifierForVendor`. It stays the same while at least one
+  app from the same vendor (the same Apple Developer account) is installed. If
+  the user deletes every app from that vendor and reinstalls, a new id is
+  generated.
+- **Android** returns `Settings.Secure.ANDROID_ID`. It stays the same until a
+  factory reset. On Android 8.0 and newer the value is scoped to your app's
+  signing key, so different apps see different ids on the same device.
+
+This is the identifier that both platforms recommend for ordinary app use. It
+needs no extra permissions and does not expose a hardware serial number. It is
+not designed for cross-vendor tracking and is not guaranteed to be globally
+unique across the entire world, only stable for your app on a given device.
+
+### getBundleId vs getBaseBundleId
+
+- `getBundleId()` returns the identifier of the build that is actually running.
+  On Android this includes any `applicationIdSuffix` from your Gradle config,
+  so a debug build can report `com.acme.app.debug`. On iOS it is whatever
+  bundle identifier the running build was signed with, including any `.dev` or
+  `.staging` suffix.
+- `getBaseBundleId()` returns the same value with one recognised build-variant
+  suffix removed. For example `com.acme.app.debug` becomes `com.acme.app`.
+
+The suffixes that are stripped are: `debug`, `dev`, `development`, `staging`,
+`stg`, `qa`, `test`, `alpha`, `beta`, `release`, `internal`. Only the final
+segment is checked, and only if it matches that list, so a normal id such as
+`com.acme.app` is never shortened by mistake. Use `getBaseBundleId()` when you
+want one identity for an app across all of its build variants, for example as a
+key in analytics or backend records.
+
+### getInstallerSource
+
+Tells you where the installed build came from.
+
+- **Android** returns the package name of the installer. Common values are
+  `com.android.vending` (Google Play) and `com.amazon.venezia` (Amazon
+  Appstore). A build installed with `adb`, a file manager, or a CI device farm
+  usually returns an empty string.
+- **iOS** has no public installer API, so the library infers the source from
+  the App Store receipt: `"TestFlight"` for a TestFlight build, `"AppStore"`
+  for a build delivered through the App Store, and `"Other"` for development,
+  simulator, or sideloaded builds.
+
+### Install and update times
+
+`getFirstInstallTime()` and `getLastUpdateTime()` return epoch milliseconds.
+
+- **Android** reads exact values from `PackageInfo.firstInstallTime` and
+  `PackageInfo.lastUpdateTime`.
+- **iOS** has no public API for these, so the library uses a filesystem
+  heuristic: the creation date of the app's Documents directory approximates
+  the first install, and the modification date of the app executable
+  approximates the last update. Treat the iOS numbers as a best effort rather
+  than an exact record.
+
+### isEmulator
+
+Returns `true` when the app is running on a simulator (iOS) or an emulator
+(Android).
+
+- **iOS** uses a compile-time simulator flag, so the result is reliable.
+- **Android** has no single official flag, so the library inspects standard
+  `Build` properties (fingerprint, model, hardware, manufacturer, product).
+  This detects the common emulators, including the Android Studio AVDs and
+  Genymotion. Treat it as a strong best effort rather than a guarantee.
+
+---
+
+## How it works
+
+The native module implements the classic React Native constants API
+(`constantsToExport` on iOS, `getConstants()` on Android). The platform builds
+a single dictionary of values when the module is created and hands it to
+JavaScript. The JavaScript layer reads that dictionary once, normalises every
+value, caches the result, and returns it from each getter.
+
+Because the values are constants rather than method calls, there is no
+asynchronous message and no serialization cost at call time. This is why every
+function in the API can be synchronous, and why the library adds effectively
+nothing to startup beyond reading a handful of system properties.
+
+The JavaScript layer also supports both shapes that React Native can hand it:
+constants attached directly to the module object (legacy bridge) and a
+`getConstants()` method (New Architecture interop). You do not need to configure
+anything for either case.
+
+---
+
+## TypeScript
+
+The package ships its own type definitions. The default export, every named
+function, and the `AppDeviceInfoConstants` interface are fully typed. No
+`@types` package is required.
+
+```ts
+import AppDeviceInfo, {
+  getInfo,
+  type AppDeviceInfoConstants,
+} from 'react-native-app-device-info';
+
+const info: AppDeviceInfoConstants = getInfo();
+```
+
+---
+
+## Platform support matrix
+
+| Value              | iOS                       | Android                |
+| ------------------ | ------------------------- | ---------------------- |
+| App version        | Yes                       | Yes                    |
+| Build number       | Yes                       | Yes                    |
+| Bundle / package id| Yes                       | Yes                    |
+| Base bundle id     | Yes                       | Yes                    |
+| App name           | Yes                       | Yes                    |
+| OS name / version  | Yes                       | Yes                    |
+| Device type        | Yes                       | Yes                    |
+| Device model       | Yes                       | Yes                    |
+| Device brand       | `"Apple"`                 | Yes                    |
+| Is tablet          | Yes                       | Yes                    |
+| Unique id          | Yes (`identifierForVendor`) | Yes (`ANDROID_ID`)   |
+| Is emulator        | Yes (reliable)            | Yes (heuristic)        |
+| Locale             | Yes                       | Yes                    |
+| Timezone           | Yes                       | Yes                    |
+| API level          | `0` (not applicable)      | Yes                    |
+| Installer source   | Yes (inferred)            | Yes                    |
+| First install time | Heuristic                 | Yes (exact)            |
+| Last update time   | Heuristic                 | Yes (exact)            |
+
+---
+
+## Troubleshooting
+
+**The module is not linked / values throw an error.**
+Rebuild the native app after installing. A Metro reload does not include new
+native code. On iOS, run `pod install` first.
+
+**It does not work in Expo Go.**
+Expo Go cannot load custom native modules. Use a development build with
+`npx expo prebuild` and `npx expo run:ios` or `npx expo run:android`.
+
+**`getBuildNumber()` returns a different value than I set.**
+It returns the value of the build that is actually running. Make sure you are
+looking at the same build configuration (debug vs release) that you edited.
+
+**`getApiLevel()` returns `0`.**
+That is expected on iOS, which has no Android-style API level. Use
+`getOsVersion()` on iOS instead.
+
+**`getFirstInstallTime()` looks wrong on iOS.**
+iOS does not expose an install timestamp, so the value is a filesystem-based
+estimate. Use the Android values when you need exact timing.
+
+---
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,48 @@
+buildscript {
+  ext.getExtOrDefault = { name, fallback ->
+    rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
+  }
+  repositories {
+    google()
+    mavenCentral()
+  }
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.1.1"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion', '1.8.0')}"
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+def getExtOrIntegerDefault(name, fallback) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
+}
+
+android {
+  namespace "com.appdeviceinfo"
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion", 34)
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion", 21)
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion", 34)
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-native:+"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/com/appdeviceinfo/AppDeviceInfoModule.kt

@@ -0,0 +1,120 @@
+package com.appdeviceinfo
+
+import android.content.Context
+import android.content.pm.PackageInfo
+import android.os.Build
+import android.provider.Settings
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+
+class AppDeviceInfoModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  override fun getName(): String = NAME
+
+  // Constants are computed natively and read synchronously from JS at load
+  // time. No async bridge call is ever made — fastest possible path.
+  override fun getConstants(): Map<String, Any> {
+    val ctx: Context = reactApplicationContext
+    val map = HashMap<String, Any>()
+
+    var appVersion = ""
+    var buildNumber = ""
+    var appName = ""
+    var firstInstallTime = 0.0
+    var lastUpdateTime = 0.0
+    var installerSource = ""
+    val bundleId = ctx.packageName ?: ""
+
+    try {
+      val pm = ctx.packageManager
+      val info: PackageInfo = pm.getPackageInfo(bundleId, 0)
+      appVersion = info.versionName ?: ""
+      buildNumber =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+          info.longVersionCode.toString()
+        } else {
+          @Suppress("DEPRECATION")
+          info.versionCode.toString()
+        }
+      appName = ctx.applicationInfo.loadLabel(pm).toString()
+      firstInstallTime = info.firstInstallTime.toDouble()
+      lastUpdateTime = info.lastUpdateTime.toDouble()
+      installerSource =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+          pm.getInstallSourceInfo(bundleId).installingPackageName ?: ""
+        } else {
+          @Suppress("DEPRECATION")
+          pm.getInstallerPackageName(bundleId) ?: ""
+        }
+    } catch (e: Exception) {
+      // Leave defaults; never crash app startup over metadata.
+    }
+
+    val locale =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        ctx.resources.configuration.locales[0]
+      } else {
+        @Suppress("DEPRECATION")
+        ctx.resources.configuration.locale
+      }
+
+    val deviceId =
+      try {
+        Settings.Secure.getString(ctx.contentResolver, Settings.Secure.ANDROID_ID) ?: ""
+      } catch (e: Exception) {
+        ""
+      }
+
+    map["appVersion"] = appVersion
+    map["buildNumber"] = buildNumber
+    map["bundleId"] = bundleId
+    map["appName"] = appName
+
+    map["osName"] = "Android"
+    map["osVersion"] = Build.VERSION.RELEASE ?: ""
+    map["deviceType"] = "android"
+
+    map["deviceModel"] = Build.MODEL ?: ""
+    map["deviceBrand"] = Build.MANUFACTURER ?: ""
+    map["isTablet"] = isTablet(ctx)
+
+    map["deviceId"] = deviceId
+
+    map["isEmulator"] = isEmulator()
+    map["deviceLocale"] = locale.toLanguageTag()
+    map["timezone"] = java.util.TimeZone.getDefault().id ?: ""
+    map["apiLevel"] = Build.VERSION.SDK_INT
+
+    map["installerSource"] = installerSource
+    map["firstInstallTime"] = firstInstallTime
+    map["lastUpdateTime"] = lastUpdateTime
+
+    return map
+  }
+
+  private fun isEmulator(): Boolean {
+    return (Build.FINGERPRINT.startsWith("generic") ||
+      Build.FINGERPRINT.startsWith("unknown") ||
+      Build.MODEL.contains("google_sdk") ||
+      Build.MODEL.contains("Emulator") ||
+      Build.MODEL.contains("Android SDK built for") ||
+      Build.MANUFACTURER.contains("Genymotion") ||
+      Build.HARDWARE.contains("goldfish") ||
+      Build.HARDWARE.contains("ranchu") ||
+      Build.PRODUCT == "google_sdk" ||
+      Build.PRODUCT == "sdk" ||
+      Build.PRODUCT.contains("sdk_gphone") ||
+      (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic")))
+  }
+
+  private fun isTablet(ctx: Context): Boolean {
+    val layout = ctx.resources.configuration.screenLayout and
+      android.content.res.Configuration.SCREENLAYOUT_SIZE_MASK
+    return layout >= android.content.res.Configuration.SCREENLAYOUT_SIZE_LARGE
+  }
+
+  companion object {
+    const val NAME = "AppDeviceInfo"
+  }
+}

package/android/src/main/java/com/appdeviceinfo/AppDeviceInfoPackage.kt

@@ -0,0 +1,16 @@
+package com.appdeviceinfo
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class AppDeviceInfoPackage : ReactPackage {
+  override fun createNativeModules(
+    reactContext: ReactApplicationContext
+  ): List<NativeModule> = listOf(AppDeviceInfoModule(reactContext))
+
+  override fun createViewManagers(
+    reactContext: ReactApplicationContext
+  ): List<ViewManager<*, *>> = emptyList()
+}

package/ios/AppDeviceInfo.h

@@ -0,0 +1,4 @@
+#import <React/RCTBridgeModule.h>
+
+@interface AppDeviceInfo : NSObject <RCTBridgeModule>
+@end

package/ios/AppDeviceInfo.m

@@ -0,0 +1,108 @@
+#import "AppDeviceInfo.h"
+#import <sys/utsname.h>
+#import <UIKit/UIKit.h>
+
+@implementation AppDeviceInfo
+
+RCT_EXPORT_MODULE();
+
+// Constants are computed natively and read synchronously from JS at load time.
+// No async bridge call is ever made — this is the fastest possible path.
++ (BOOL)requiresMainQueueSetup
+{
+  // We touch UIDevice, so build the constants on the main queue.
+  return YES;
+}
+
+- (NSString *)hardwareModelIdentifier
+{
+  struct utsname systemInfo;
+  uname(&systemInfo);
+  return [NSString stringWithCString:systemInfo.machine
+                           encoding:NSUTF8StringEncoding];
+}
+
+- (NSDictionary *)constantsToExport
+{
+  NSBundle *bundle = [NSBundle mainBundle];
+  NSDictionary *info = [bundle infoDictionary];
+
+  NSString *appVersion = info[@"CFBundleShortVersionString"] ?: @"";
+  NSString *buildNumber = info[@"CFBundleVersion"] ?: @"";
+  NSString *bundleId = [bundle bundleIdentifier] ?: @"";
+  NSString *appName = info[@"CFBundleDisplayName"]
+                        ?: (info[@"CFBundleName"] ?: @"");
+
+  UIDevice *device = [UIDevice currentDevice];
+  NSString *osName = [device systemName] ?: @"iOS";
+  NSString *osVersion = [device systemVersion] ?: @"";
+
+  NSString *deviceId = [[device identifierForVendor] UUIDString] ?: @"";
+  BOOL isTablet = ([device userInterfaceIdiom] == UIUserInterfaceIdiomPad);
+
+  BOOL isSimulator = NO;
+#if TARGET_OS_SIMULATOR
+  isSimulator = YES;
+#endif
+
+  NSString *locale = [[NSLocale preferredLanguages] firstObject]
+                       ?: [[NSLocale currentLocale] localeIdentifier] ?: @"";
+  NSString *timezone = [[NSTimeZone localTimeZone] name] ?: @"";
+
+  // Installer source: TestFlight builds carry a "sandboxReceipt"; App Store
+  // builds carry a "receipt"; dev/sideloaded builds usually have neither.
+  NSString *installerSource = @"Other";
+  NSURL *receiptURL = [bundle appStoreReceiptURL];
+  NSString *receiptName = [receiptURL lastPathComponent];
+  if ([receiptName isEqualToString:@"sandboxReceipt"]) {
+    installerSource = @"TestFlight";
+  } else if (receiptURL &&
+             [[NSFileManager defaultManager] fileExistsAtPath:[receiptURL path]]) {
+    installerSource = @"AppStore";
+  }
+
+  // iOS has no public install/update timestamps; approximate with filesystem
+  // dates (Documents creation = first install, executable mtime = last update).
+  NSFileManager *fm = [NSFileManager defaultManager];
+  double firstInstallTime = 0;
+  double lastUpdateTime = 0;
+  NSArray *docDirs =
+    NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+  if (docDirs.count > 0) {
+    NSDate *d = [[fm attributesOfItemAtPath:docDirs[0] error:nil] fileCreationDate];
+    if (d) firstInstallTime = [d timeIntervalSince1970] * 1000.0;
+  }
+  NSString *execPath = [bundle executablePath];
+  if (execPath) {
+    NSDate *d = [[fm attributesOfItemAtPath:execPath error:nil] fileModificationDate];
+    if (d) lastUpdateTime = [d timeIntervalSince1970] * 1000.0;
+  }
+
+  return @{
+    @"appVersion": appVersion,
+    @"buildNumber": buildNumber,
+    @"bundleId": bundleId,
+    @"appName": appName,
+
+    @"osName": osName,
+    @"osVersion": osVersion,
+    @"deviceType": @"ios",
+
+    @"deviceModel": [self hardwareModelIdentifier],
+    @"deviceBrand": @"Apple",
+    @"isTablet": @(isTablet),
+
+    @"deviceId": deviceId,
+
+    @"isEmulator": @(isSimulator),
+    @"deviceLocale": locale,
+    @"timezone": timezone,
+    @"apiLevel": @0,
+
+    @"installerSource": installerSource,
+    @"firstInstallTime": @(firstInstallTime),
+    @"lastUpdateTime": @(lastUpdateTime),
+  };
+}
+
+@end

package/lib/index.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Shape of the constants exported synchronously by the native module.
+ * These are read once, at module load time — there is no async bridge call.
+ */
+export interface AppDeviceInfoConstants {
+    /** App marketing version, a.k.a. version name. iOS: CFBundleShortVersionString, Android: versionName. e.g. "1.2.3" */
+    appVersion: string;
+    /** App build number / version code. iOS: CFBundleVersion, Android: versionCode. e.g. "42" */
+    buildNumber: string;
+    /** Application/bundle identifier. e.g. "com.acme.app" */
+    bundleId: string;
+    /** Human-readable app display name. */
+    appName: string;
+    /** OS name. "iOS" or "Android". */
+    osName: string;
+    /** OS version. e.g. "17.4" or "14". */
+    osVersion: string;
+    /** Platform type, handy for branching. "ios" or "android". */
+    deviceType: 'ios' | 'android';
+    /** Hardware model identifier. iOS: e.g. "iPhone15,2". Android: Build.MODEL e.g. "Pixel 8". */
+    deviceModel: string;
+    /** Device brand / manufacturer. iOS: "Apple". Android: Build.MANUFACTURER e.g. "Google". */
+    deviceBrand: string;
+    /** Whether the device is a tablet / iPad. */
+    isTablet: boolean;
+    /**
+     * A stable unique id for this device, persistent across app launches.
+     * iOS: identifierForVendor (stable while at least one app from the same
+     *      vendor stays installed; may change if all are uninstalled).
+     * Android: Settings.Secure.ANDROID_ID (stable until factory reset; scoped
+     *      to the app signing key on Android 8+).
+     */
+    deviceId: string;
+    /** True when running on a simulator (iOS) or emulator (Android). */
+    isEmulator: boolean;
+    /** Active locale at launch in BCP-47 form, e.g. "en-US". */
+    deviceLocale: string;
+    /** IANA time zone id, e.g. "America/New_York". */
+    timezone: string;
+    /** Android API level (Build.VERSION.SDK_INT), e.g. 34. Always 0 on iOS. */
+    apiLevel: number;
+    /**
+     * Where the app was installed from.
+     * Android: installing package, e.g. "com.android.vending" (Play Store) or
+     *          "" when sideloaded.
+     * iOS: "AppStore", "TestFlight", or "Other" (dev/sideloaded builds).
+     */
+    installerSource: string;
+    /** First-install time as epoch milliseconds. 0 if unknown (iOS is a heuristic). */
+    firstInstallTime: number;
+    /** Last-update time as epoch milliseconds. 0 if unknown (iOS is a heuristic). */
+    lastUpdateTime: number;
+}
+/**
+ * Returns every value at once. Synchronous — no Promise, no bridge round-trip.
+ * The result is computed once and cached.
+ */
+export declare function getInfo(): AppDeviceInfoConstants;
+/** App marketing version / version name, e.g. "1.2.3". */
+export declare const getVersion: () => string;
+/** App build number / version code, e.g. "42". */
+export declare const getBuildNumber: () => string;
+/** Bundle / application id, e.g. "com.acme.app". On Android this is the
+ *  runtime applicationId, including any build-variant suffix (".debug" etc). */
+export declare const getBundleId: () => string;
+/** Bundle id with a known build-variant suffix removed, e.g.
+ *  "com.acme.app.debug" -> "com.acme.app". Only strips recognised suffixes
+ *  (see KNOWN_BUNDLE_SUFFIXES); otherwise returns the id unchanged. */
+export declare const getBaseBundleId: () => string;
+/** App display name. */
+export declare const getAppName: () => string;
+/** Convenience: "1.2.3 (42)". */
+export declare const getReadableVersion: () => string;
+/** OS name: "iOS" or "Android". */
+export declare const getOsName: () => string;
+/** OS version, e.g. "17.4". */
+export declare const getOsVersion: () => string;
+/** Platform type: "ios" or "android". */
+export declare const getDeviceType: () => "ios" | "android";
+/** Hardware model identifier, e.g. "iPhone15,2" or "Pixel 8". */
+export declare const getDeviceModel: () => string;
+/** Device brand / manufacturer, e.g. "Apple" or "Google". */
+export declare const getDeviceBrand: () => string;
+/** True on iPad / Android tablets. */
+export declare const isTablet: () => boolean;
+/** Stable, persistent unique device id. See `AppDeviceInfoConstants.deviceId`. */
+export declare const getUniqueId: () => string;
+/** True on a simulator (iOS) / emulator (Android). */
+export declare const isEmulator: () => boolean;
+/** Active locale at launch, BCP-47, e.g. "en-US". */
+export declare const getDeviceLocale: () => string;
+/** IANA time zone id, e.g. "America/New_York". */
+export declare const getTimezone: () => string;
+/** Android API level (e.g. 34); 0 on iOS. */
+export declare const getApiLevel: () => number;
+/** Where the app was installed from. See `AppDeviceInfoConstants.installerSource`. */
+export declare const getInstallerSource: () => string;
+/** First-install time, epoch ms (0 if unknown). */
+export declare const getFirstInstallTime: () => number;
+/** Last-update time, epoch ms (0 if unknown). */
+export declare const getLastUpdateTime: () => number;
+declare const AppDeviceInfo: {
+    getInfo: typeof getInfo;
+    getVersion: () => string;
+    getBuildNumber: () => string;
+    getBundleId: () => string;
+    getBaseBundleId: () => string;
+    getAppName: () => string;
+    getReadableVersion: () => string;
+    getOsName: () => string;
+    getOsVersion: () => string;
+    getDeviceType: () => "ios" | "android";
+    getDeviceModel: () => string;
+    getDeviceBrand: () => string;
+    isTablet: () => boolean;
+    getUniqueId: () => string;
+    isEmulator: () => boolean;
+    getDeviceLocale: () => string;
+    getTimezone: () => string;
+    getApiLevel: () => number;
+    getInstallerSource: () => string;
+    getFirstInstallTime: () => number;
+    getLastUpdateTime: () => number;
+};
+export default AppDeviceInfo;

package/lib/index.js

@@ -0,0 +1,162 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastUpdateTime = exports.getFirstInstallTime = exports.getInstallerSource = exports.getApiLevel = exports.getTimezone = exports.getDeviceLocale = exports.isEmulator = exports.getUniqueId = exports.isTablet = exports.getDeviceBrand = exports.getDeviceModel = exports.getDeviceType = exports.getOsVersion = exports.getOsName = exports.getReadableVersion = exports.getAppName = exports.getBaseBundleId = exports.getBundleId = exports.getBuildNumber = exports.getVersion = void 0;
+exports.getInfo = getInfo;
+const react_native_1 = require("react-native");
+const LINKING_ERROR = `The package 'react-native-app-device-info' doesn't seem to be linked. Make sure:\n\n` +
+    react_native_1.Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+    '- You rebuilt the app after installing the package\n' +
+    '- You are not using Expo Go (use a development build instead)\n';
+/** Build-variant suffixes stripped by `getBaseBundleId()`. */
+const KNOWN_BUNDLE_SUFFIXES = [
+    'debug',
+    'dev',
+    'development',
+    'staging',
+    'stg',
+    'qa',
+    'test',
+    'alpha',
+    'beta',
+    'release',
+    'internal',
+];
+const Native = (_a = react_native_1.NativeModules.AppDeviceInfo) !== null && _a !== void 0 ? _a : null;
+function readConstants() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+    if (!Native) {
+        throw new Error(LINKING_ERROR);
+    }
+    // New Architecture / TurboModule interop exposes a getConstants() method;
+    // legacy bridge exposes the values directly on the module object. Support both.
+    const source = typeof Native.getConstants === 'function' ? Native.getConstants() : Native;
+    return {
+        appVersion: String((_a = source.appVersion) !== null && _a !== void 0 ? _a : ''),
+        buildNumber: String((_b = source.buildNumber) !== null && _b !== void 0 ? _b : ''),
+        bundleId: String((_c = source.bundleId) !== null && _c !== void 0 ? _c : ''),
+        appName: String((_d = source.appName) !== null && _d !== void 0 ? _d : ''),
+        osName: String((_e = source.osName) !== null && _e !== void 0 ? _e : ''),
+        osVersion: String((_f = source.osVersion) !== null && _f !== void 0 ? _f : ''),
+        deviceType: (source.deviceType === 'android' ? 'android' : 'ios'),
+        deviceModel: String((_g = source.deviceModel) !== null && _g !== void 0 ? _g : ''),
+        deviceBrand: String((_h = source.deviceBrand) !== null && _h !== void 0 ? _h : ''),
+        isTablet: Boolean(source.isTablet),
+        deviceId: String((_j = source.deviceId) !== null && _j !== void 0 ? _j : ''),
+        isEmulator: Boolean(source.isEmulator),
+        deviceLocale: String((_k = source.deviceLocale) !== null && _k !== void 0 ? _k : ''),
+        timezone: String((_l = source.timezone) !== null && _l !== void 0 ? _l : ''),
+        apiLevel: Number((_m = source.apiLevel) !== null && _m !== void 0 ? _m : 0),
+        installerSource: String((_o = source.installerSource) !== null && _o !== void 0 ? _o : ''),
+        firstInstallTime: Number((_p = source.firstInstallTime) !== null && _p !== void 0 ? _p : 0),
+        lastUpdateTime: Number((_q = source.lastUpdateTime) !== null && _q !== void 0 ? _q : 0),
+    };
+}
+let cached = null;
+/**
+ * Returns every value at once. Synchronous — no Promise, no bridge round-trip.
+ * The result is computed once and cached.
+ */
+function getInfo() {
+    if (cached === null) {
+        cached = readConstants();
+    }
+    return cached;
+}
+// ---- App ----
+/** App marketing version / version name, e.g. "1.2.3". */
+const getVersion = () => getInfo().appVersion;
+exports.getVersion = getVersion;
+/** App build number / version code, e.g. "42". */
+const getBuildNumber = () => getInfo().buildNumber;
+exports.getBuildNumber = getBuildNumber;
+/** Bundle / application id, e.g. "com.acme.app". On Android this is the
+ *  runtime applicationId, including any build-variant suffix (".debug" etc). */
+const getBundleId = () => getInfo().bundleId;
+exports.getBundleId = getBundleId;
+/** Bundle id with a known build-variant suffix removed, e.g.
+ *  "com.acme.app.debug" -> "com.acme.app". Only strips recognised suffixes
+ *  (see KNOWN_BUNDLE_SUFFIXES); otherwise returns the id unchanged. */
+const getBaseBundleId = () => {
+    const id = getInfo().bundleId;
+    const lastDot = id.lastIndexOf('.');
+    if (lastDot === -1)
+        return id;
+    const last = id.slice(lastDot + 1).toLowerCase();
+    return KNOWN_BUNDLE_SUFFIXES.includes(last) ? id.slice(0, lastDot) : id;
+};
+exports.getBaseBundleId = getBaseBundleId;
+/** App display name. */
+const getAppName = () => getInfo().appName;
+exports.getAppName = getAppName;
+/** Convenience: "1.2.3 (42)". */
+const getReadableVersion = () => `${getInfo().appVersion} (${getInfo().buildNumber})`;
+exports.getReadableVersion = getReadableVersion;
+// ---- Device / OS ----
+/** OS name: "iOS" or "Android". */
+const getOsName = () => getInfo().osName;
+exports.getOsName = getOsName;
+/** OS version, e.g. "17.4". */
+const getOsVersion = () => getInfo().osVersion;
+exports.getOsVersion = getOsVersion;
+/** Platform type: "ios" or "android". */
+const getDeviceType = () => getInfo().deviceType;
+exports.getDeviceType = getDeviceType;
+/** Hardware model identifier, e.g. "iPhone15,2" or "Pixel 8". */
+const getDeviceModel = () => getInfo().deviceModel;
+exports.getDeviceModel = getDeviceModel;
+/** Device brand / manufacturer, e.g. "Apple" or "Google". */
+const getDeviceBrand = () => getInfo().deviceBrand;
+exports.getDeviceBrand = getDeviceBrand;
+/** True on iPad / Android tablets. */
+const isTablet = () => getInfo().isTablet;
+exports.isTablet = isTablet;
+/** Stable, persistent unique device id. See `AppDeviceInfoConstants.deviceId`. */
+const getUniqueId = () => getInfo().deviceId;
+exports.getUniqueId = getUniqueId;
+// ---- Environment ----
+/** True on a simulator (iOS) / emulator (Android). */
+const isEmulator = () => getInfo().isEmulator;
+exports.isEmulator = isEmulator;
+/** Active locale at launch, BCP-47, e.g. "en-US". */
+const getDeviceLocale = () => getInfo().deviceLocale;
+exports.getDeviceLocale = getDeviceLocale;
+/** IANA time zone id, e.g. "America/New_York". */
+const getTimezone = () => getInfo().timezone;
+exports.getTimezone = getTimezone;
+/** Android API level (e.g. 34); 0 on iOS. */
+const getApiLevel = () => getInfo().apiLevel;
+exports.getApiLevel = getApiLevel;
+/** Where the app was installed from. See `AppDeviceInfoConstants.installerSource`. */
+const getInstallerSource = () => getInfo().installerSource;
+exports.getInstallerSource = getInstallerSource;
+/** First-install time, epoch ms (0 if unknown). */
+const getFirstInstallTime = () => getInfo().firstInstallTime;
+exports.getFirstInstallTime = getFirstInstallTime;
+/** Last-update time, epoch ms (0 if unknown). */
+const getLastUpdateTime = () => getInfo().lastUpdateTime;
+exports.getLastUpdateTime = getLastUpdateTime;
+const AppDeviceInfo = {
+    getInfo,
+    getVersion: exports.getVersion,
+    getBuildNumber: exports.getBuildNumber,
+    getBundleId: exports.getBundleId,
+    getBaseBundleId: exports.getBaseBundleId,
+    getAppName: exports.getAppName,
+    getReadableVersion: exports.getReadableVersion,
+    getOsName: exports.getOsName,
+    getOsVersion: exports.getOsVersion,
+    getDeviceType: exports.getDeviceType,
+    getDeviceModel: exports.getDeviceModel,
+    getDeviceBrand: exports.getDeviceBrand,
+    isTablet: exports.isTablet,
+    getUniqueId: exports.getUniqueId,
+    isEmulator: exports.isEmulator,
+    getDeviceLocale: exports.getDeviceLocale,
+    getTimezone: exports.getTimezone,
+    getApiLevel: exports.getApiLevel,
+    getInstallerSource: exports.getInstallerSource,
+    getFirstInstallTime: exports.getFirstInstallTime,
+    getLastUpdateTime: exports.getLastUpdateTime,
+};
+exports.default = AppDeviceInfo;

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "react-native-app-device-info",
+  "version": "1.0.0",
+  "description": "Minimal, fast, synchronous app & device info for React Native — app version, build number, OS version, device name/type and a persistent unique device id. iOS + Android, Old & New Architecture.",
+  "main": "lib/index.js",
+  "module": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "react-native.config.js",
+    "react-native-app-device-info.podspec",
+    "!android/build",
+    "!**/build",
+    "!**/__tests__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepare": "npm run build",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "node ./scripts/test.js"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "app-version",
+    "build-number",
+    "version-name",
+    "device-info",
+    "device-id",
+    "unique-id",
+    "os-version",
+    "device-name",
+    "device-type",
+    "bundle-id",
+    "expo"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/getsettalk/react-native-app-device-info.git"
+  },
+  "author": "Sujeet Kumar",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/getsettalk/react-native-app-device-info/issues"
+  },
+  "homepage": "https://github.com/getsettalk/react-native-app-device-info#readme",
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "react": "18.2.0",
+    "react-native": "0.74.5",
+    "typescript": "^5.4.0"
+  }
+}

package/react-native-app-device-info.podspec

@@ -0,0 +1,21 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-app-device-info"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.author       = package["author"]
+  s.platforms    = { :ios => "12.0" }
+  s.source       = { :git => package["repository"]["url"], :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+  s.requires_arc = true
+
+  # Works on both the legacy bridge and the New Architecture interop layer.
+  install_modules_dependencies(s) if respond_to?(:install_modules_dependencies)
+  s.dependency "React-Core" unless respond_to?(:install_modules_dependencies)
+end

package/react-native.config.js

@@ -0,0 +1,16 @@
+// Explicit autolinking config so the native module is picked up reliably
+// on both platforms across React Native versions.
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: 'android',
+        packageImportPath: 'import com.appdeviceinfo.AppDeviceInfoPackage;',
+        packageInstance: 'new AppDeviceInfoPackage()',
+      },
+      ios: {
+        podspecPath: __dirname + '/react-native-app-device-info.podspec',
+      },
+    },
+  },
+};

package/src/index.ts

@@ -0,0 +1,213 @@
+import { NativeModules, Platform } from 'react-native';
+
+const LINKING_ERROR =
+  `The package 'react-native-app-device-info' doesn't seem to be linked. Make sure:\n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go (use a development build instead)\n';
+
+/**
+ * Shape of the constants exported synchronously by the native module.
+ * These are read once, at module load time — there is no async bridge call.
+ */
+export interface AppDeviceInfoConstants {
+  /** App marketing version, a.k.a. version name. iOS: CFBundleShortVersionString, Android: versionName. e.g. "1.2.3" */
+  appVersion: string;
+  /** App build number / version code. iOS: CFBundleVersion, Android: versionCode. e.g. "42" */
+  buildNumber: string;
+  /** Application/bundle identifier. e.g. "com.acme.app" */
+  bundleId: string;
+  /** Human-readable app display name. */
+  appName: string;
+
+  /** OS name. "iOS" or "Android". */
+  osName: string;
+  /** OS version. e.g. "17.4" or "14". */
+  osVersion: string;
+  /** Platform type, handy for branching. "ios" or "android". */
+  deviceType: 'ios' | 'android';
+
+  /** Hardware model identifier. iOS: e.g. "iPhone15,2". Android: Build.MODEL e.g. "Pixel 8". */
+  deviceModel: string;
+  /** Device brand / manufacturer. iOS: "Apple". Android: Build.MANUFACTURER e.g. "Google". */
+  deviceBrand: string;
+  /** Whether the device is a tablet / iPad. */
+  isTablet: boolean;
+
+  /**
+   * A stable unique id for this device, persistent across app launches.
+   * iOS: identifierForVendor (stable while at least one app from the same
+   *      vendor stays installed; may change if all are uninstalled).
+   * Android: Settings.Secure.ANDROID_ID (stable until factory reset; scoped
+   *      to the app signing key on Android 8+).
+   */
+  deviceId: string;
+
+  /** True when running on a simulator (iOS) or emulator (Android). */
+  isEmulator: boolean;
+  /** Active locale at launch in BCP-47 form, e.g. "en-US". */
+  deviceLocale: string;
+  /** IANA time zone id, e.g. "America/New_York". */
+  timezone: string;
+  /** Android API level (Build.VERSION.SDK_INT), e.g. 34. Always 0 on iOS. */
+  apiLevel: number;
+
+  /**
+   * Where the app was installed from.
+   * Android: installing package, e.g. "com.android.vending" (Play Store) or
+   *          "" when sideloaded.
+   * iOS: "AppStore", "TestFlight", or "Other" (dev/sideloaded builds).
+   */
+  installerSource: string;
+  /** First-install time as epoch milliseconds. 0 if unknown (iOS is a heuristic). */
+  firstInstallTime: number;
+  /** Last-update time as epoch milliseconds. 0 if unknown (iOS is a heuristic). */
+  lastUpdateTime: number;
+}
+
+/** Build-variant suffixes stripped by `getBaseBundleId()`. */
+const KNOWN_BUNDLE_SUFFIXES = [
+  'debug',
+  'dev',
+  'development',
+  'staging',
+  'stg',
+  'qa',
+  'test',
+  'alpha',
+  'beta',
+  'release',
+  'internal',
+];
+
+type NativeShape = AppDeviceInfoConstants & {
+  getConstants?: () => AppDeviceInfoConstants;
+};
+
+const Native: NativeShape | null = NativeModules.AppDeviceInfo ?? null;
+
+function readConstants(): AppDeviceInfoConstants {
+  if (!Native) {
+    throw new Error(LINKING_ERROR);
+  }
+  // New Architecture / TurboModule interop exposes a getConstants() method;
+  // legacy bridge exposes the values directly on the module object. Support both.
+  const source =
+    typeof Native.getConstants === 'function' ? Native.getConstants() : Native;
+
+  return {
+    appVersion: String(source.appVersion ?? ''),
+    buildNumber: String(source.buildNumber ?? ''),
+    bundleId: String(source.bundleId ?? ''),
+    appName: String(source.appName ?? ''),
+    osName: String(source.osName ?? ''),
+    osVersion: String(source.osVersion ?? ''),
+    deviceType: (source.deviceType === 'android' ? 'android' : 'ios'),
+    deviceModel: String(source.deviceModel ?? ''),
+    deviceBrand: String(source.deviceBrand ?? ''),
+    isTablet: Boolean(source.isTablet),
+    deviceId: String(source.deviceId ?? ''),
+    isEmulator: Boolean(source.isEmulator),
+    deviceLocale: String(source.deviceLocale ?? ''),
+    timezone: String(source.timezone ?? ''),
+    apiLevel: Number(source.apiLevel ?? 0),
+    installerSource: String(source.installerSource ?? ''),
+    firstInstallTime: Number(source.firstInstallTime ?? 0),
+    lastUpdateTime: Number(source.lastUpdateTime ?? 0),
+  };
+}
+
+let cached: AppDeviceInfoConstants | null = null;
+
+/**
+ * Returns every value at once. Synchronous — no Promise, no bridge round-trip.
+ * The result is computed once and cached.
+ */
+export function getInfo(): AppDeviceInfoConstants {
+  if (cached === null) {
+    cached = readConstants();
+  }
+  return cached;
+}
+
+// ---- App ----
+/** App marketing version / version name, e.g. "1.2.3". */
+export const getVersion = (): string => getInfo().appVersion;
+/** App build number / version code, e.g. "42". */
+export const getBuildNumber = (): string => getInfo().buildNumber;
+/** Bundle / application id, e.g. "com.acme.app". On Android this is the
+ *  runtime applicationId, including any build-variant suffix (".debug" etc). */
+export const getBundleId = (): string => getInfo().bundleId;
+/** Bundle id with a known build-variant suffix removed, e.g.
+ *  "com.acme.app.debug" -> "com.acme.app". Only strips recognised suffixes
+ *  (see KNOWN_BUNDLE_SUFFIXES); otherwise returns the id unchanged. */
+export const getBaseBundleId = (): string => {
+  const id = getInfo().bundleId;
+  const lastDot = id.lastIndexOf('.');
+  if (lastDot === -1) return id;
+  const last = id.slice(lastDot + 1).toLowerCase();
+  return KNOWN_BUNDLE_SUFFIXES.includes(last) ? id.slice(0, lastDot) : id;
+};
+/** App display name. */
+export const getAppName = (): string => getInfo().appName;
+/** Convenience: "1.2.3 (42)". */
+export const getReadableVersion = (): string =>
+  `${getInfo().appVersion} (${getInfo().buildNumber})`;
+
+// ---- Device / OS ----
+/** OS name: "iOS" or "Android". */
+export const getOsName = (): string => getInfo().osName;
+/** OS version, e.g. "17.4". */
+export const getOsVersion = (): string => getInfo().osVersion;
+/** Platform type: "ios" or "android". */
+export const getDeviceType = (): 'ios' | 'android' => getInfo().deviceType;
+/** Hardware model identifier, e.g. "iPhone15,2" or "Pixel 8". */
+export const getDeviceModel = (): string => getInfo().deviceModel;
+/** Device brand / manufacturer, e.g. "Apple" or "Google". */
+export const getDeviceBrand = (): string => getInfo().deviceBrand;
+/** True on iPad / Android tablets. */
+export const isTablet = (): boolean => getInfo().isTablet;
+/** Stable, persistent unique device id. See `AppDeviceInfoConstants.deviceId`. */
+export const getUniqueId = (): string => getInfo().deviceId;
+
+// ---- Environment ----
+/** True on a simulator (iOS) / emulator (Android). */
+export const isEmulator = (): boolean => getInfo().isEmulator;
+/** Active locale at launch, BCP-47, e.g. "en-US". */
+export const getDeviceLocale = (): string => getInfo().deviceLocale;
+/** IANA time zone id, e.g. "America/New_York". */
+export const getTimezone = (): string => getInfo().timezone;
+/** Android API level (e.g. 34); 0 on iOS. */
+export const getApiLevel = (): number => getInfo().apiLevel;
+/** Where the app was installed from. See `AppDeviceInfoConstants.installerSource`. */
+export const getInstallerSource = (): string => getInfo().installerSource;
+/** First-install time, epoch ms (0 if unknown). */
+export const getFirstInstallTime = (): number => getInfo().firstInstallTime;
+/** Last-update time, epoch ms (0 if unknown). */
+export const getLastUpdateTime = (): number => getInfo().lastUpdateTime;
+
+const AppDeviceInfo = {
+  getInfo,
+  getVersion,
+  getBuildNumber,
+  getBundleId,
+  getBaseBundleId,
+  getAppName,
+  getReadableVersion,
+  getOsName,
+  getOsVersion,
+  getDeviceType,
+  getDeviceModel,
+  getDeviceBrand,
+  isTablet,
+  getUniqueId,
+  isEmulator,
+  getDeviceLocale,
+  getTimezone,
+  getApiLevel,
+  getInstallerSource,
+  getFirstInstallTime,
+  getLastUpdateTime,
+};
+
+export default AppDeviceInfo;