Expo (React Native)

app.json is static JSON that CLI tools can also edit; app.config.ts is code Expo CLI evaluates in Node, so it can read environment variables and compute values. When both exist, app.json is read first and handed to the dynamic config.

npx expo prebuild generates the ios and android native projects from the SDK's template, the app config and its config plugins, plus autolinked modules. Because they can be regenerated at any time, they are treated as build output and gitignored.

Expo Go is a prebuilt app with a fixed set of native libraries for one SDK. A development build is your own debug binary with expo-dev-client, holding your native code and config. Outgrow Expo Go when you need native code it lacks.

Run npx create-expo-app with an optional --template: default adds Expo Router and TypeScript for multi-screen apps, blank is minimal, tabs sets up file-based tab navigation, and bare-minimum also generates the android and ios folders.

Expo CLI loads .env files, and Metro replaces each static process.env.EXPO_PUBLIC_NAME reference in your code with its literal value when it builds a release bundle. In a release bundle the value is frozen as plain text until the next build or update.

Render CameraView once camera permission is granted, keep a ref, wait for onCameraReady, then call ref.current.takePictureAsync(options). It resolves with a uri to a temporary cache file, so copy it somewhere permanent before relying on it.

npx expo install looks the package up in the installed SDK's list of known-compatible versions and installs that version with your package manager. npm install takes the latest release, which may target a different React Native version.

The Expo Modules API declares a module in a Swift and Kotlin DSL and validates arguments at runtime; a Turbo Module starts from a TypeScript spec that Codegen turns into native interfaces. Both run over JSI; C++ work favours Turbo Modules.

When status is 'denied' and canAskAgain is false, the system will not show the prompt again, so explain why location helps, offer Linking.openSettings(), and re-read the permission with the get function when the user comes back.

An Expo SDK release is built and tested against a single React Native version, and its packages expect that version. SDK 57 targets React Native 0.86.3, so moving to a newer React Native means moving to the SDK that targets it.

Each file under src/app with a default export becomes a screen whose URL mirrors its path, and each _layout.tsx wraps its directory's routes in a navigator such as Stack, Tabs or Slot, so the folder tree becomes the navigator tree.

Square brackets make a dynamic segment: src/app/product/[id].tsx matches /product/42 and any other single segment, and the screen reads it with useLocalSearchParams(), which returns id as the string '42'.

Link navigates declaratively when a tap should reach a known href and renders a real anchor on web; the router object suits navigation after logic, such as a finished request. asChild hands Link's press to one child, like a Pressable.

A folder named in parentheses, such as (tabs), groups routes under a shared layout without adding a URL segment, and index.tsx is its folder's default route, so src/app/(tabs)/index.tsx answers / and the tab bar becomes the first screen.

useLocalSearchParams returns the params of the route the component belongs to and ignores other screens' URLs; useGlobalSearchParams follows the currently focused URL and re-renders background screens on every change, so screens should use the local hook.

An Expo config plugin is a synchronous function that takes the app config and optional props and returns the config. A mod plugin like withInfoPlist registers an async callback that edits the parsed Info.plist during npx expo prebuild.

Each plugins entry names a config plugin, a Node.js function that edits the Expo config and registers native file changes. Those changes are written at prebuild, so they reach users only in a new native build, never through a JavaScript update.

Add ["expo-build-properties", { "android": { "minSdkVersion": 26 } }] to plugins and re-run prebuild. The plugin writes android.minSdkVersion into android/gradle.properties, which the generated Gradle build reads.

Plugin functions run in array order, but each mod for a file wraps the earlier ones, so at prebuild the later plugin's edit runs first and the earlier plugin's edit runs last. For the same manifest key, the plugin listed earlier wins.

Write two plugin functions and compose them: withEntitlementsPlist adds the group to the com.apple.security.application-groups array only if missing, and withAndroidManifest uses AndroidConfig.Manifest.addMetaDataItemToMainApplication, which updates an existing entry instead of duplicating it.

Android builds are signed with a keystore (key alias and passwords); iOS builds need a distribution certificate plus an app-specific provisioning profile. By default credentialsSource is remote: EAS generates them on the first eas build and stores them encrypted on its servers.

An EAS build profile is a named object under build in eas.json describing one kind of binary; eas build --profile <name> selects it. Keys like developmentClient, distribution, ios.simulator, env and channel make each profile's binary different.

EAS Submit is a hosted service that uploads an existing .ipa or .aab to App Store Connect or Google Play. By default an iOS build lands in TestFlight and an Android build on the internal track; nothing goes to public review automatically.

With remote, EAS servers store versionCode and buildNumber and inject them at build time; autoIncrement bumps the server counter. With local, the project files are the truth and autoIncrement edits app.json, which you must commit.

Run eas build --profile production --auto-submit: each finished build is handed to EAS Submit using the submit profile with the same name as the build profile. Put ascAppId and a groups array in that profile's ios block.

Fix the text, then run eas update --channel production --environment production --message "Fix typo". EAS bundles the JavaScript, uploads it to the branch production points at, and compatible production builds download it on a later launch.

By default expo-updates checks on every cold launch (checkAutomatically: ON_LOAD) but waits 0 ms for the result (fallbackToCacheTimeout: 0), so the app starts on its current bundle, downloads the update in the background and runs it on the next cold start.

runtimeVersion labels the native layer a build contains; EAS Update serves an update only to builds whose runtime version and platform match exactly. Any change to native code or native config needs a new build and a new runtime version.

A channel is a name compiled into a build; a branch is an ordered list of published updates. Each channel points at a branch, and a build runs that branch's newest update matching its runtime version and platform.

Call Updates.checkForUpdateAsync() at a sensible moment, then fetchUpdateAsync() if isAvailable is true; when useUpdates() reports isUpdatePending, show a restart prompt whose button calls Updates.reloadAsync(). If the reader declines, the update runs on the next cold start.