expo-harmony-toolkit 1.7.0 → 1.7.2

package/build/core/template.js

@@ -23,6 +23,7 @@ const uiStack_1 = require("../data/uiStack");
 const project_1 = require("./project");
 const javascriptDependencies_1 = require("./javascriptDependencies");
 const report_1 = require("./report");
+const signing_1 = require("./signing");
 const TEMPLATE_ROOT = path_1.default.resolve(__dirname, '..', '..', 'templates', 'harmony');
 const TEMPLATE_FILE_PATHS = [
     'README.md',
@@ -149,7 +150,9 @@ async function syncProjectTemplate(projectRoot, force = false, options = {}) {
 async function buildManagedFiles(loadedProject, identifiers, previousToolkitConfig) {
     const hasExpoRouter = usesExpoRouter(loadedProject.packageJson);
     const enabledCapabilities = (0, capabilities_1.getCapabilityDefinitionsForProject)(loadedProject.packageJson);
+    const hasManagedExpoHarmonyPackage = enabledCapabilities.some((capability) => capability.runtimeMode !== 'shim');
     const requestedHarmonyPermissions = (0, capabilities_1.collectCapabilityHarmonyPermissions)(loadedProject.packageJson);
+    const signingLocalConfig = await (0, signing_1.readSigningLocalConfig)(loadedProject.projectRoot);
     const hvigorPluginFilename = await (0, project_1.resolveRnohHvigorPluginFilename)(loadedProject.projectRoot);
     const renderedHarmonyRootPackage = renderTemplate(await fs_extra_1.default.readFile(path_1.default.join(TEMPLATE_ROOT, 'oh-package.json5'), 'utf8'), loadedProject, identifiers, hvigorPluginFilename);
     const templateFiles = await Promise.all(TEMPLATE_FILE_PATHS.map(async (relativePath) => {
@@ -161,11 +164,21 @@ async function buildManagedFiles(loadedProject, identifiers, previousToolkitConf
             : renderTemplate(rawContents.toString('utf8'), loadedProject, identifiers, hvigorPluginFilename);
         return {
             relativePath: path_1.default.join('harmony', relativePath),
-            contents: relativePath === 'entry/src/main/module.json5'
-                ? renderEntryModuleConfig(identifiers.entryModuleName, requestedHarmonyPermissions)
-                : relativePath === 'entry/src/main/resources/base/element/string.json'
-                    ? renderEntryStringResources(`${identifiers.appName} official minimal Harmony sample`, identifiers.appName, requestedHarmonyPermissions)
-                    : contents,
+            contents: relativePath === 'build-profile.json5'
+                ? (0, signing_1.mergeSigningLocalConfigIntoBuildProfile)(contents.toString('utf8'), signingLocalConfig)
+                : relativePath === 'entry/src/main/module.json5'
+                    ? renderEntryModuleConfig(identifiers.entryModuleName, requestedHarmonyPermissions)
+                    : relativePath === 'entry/src/main/resources/base/element/string.json'
+                        ? renderEntryStringResources(`${identifiers.appName} official minimal Harmony sample`, identifiers.appName, requestedHarmonyPermissions)
+                        : relativePath === 'entry/src/main/ets/PackageProvider.ets'
+                            ? renderPackageProvider({
+                                hasManagedExpoHarmonyPackage,
+                            })
+                            : relativePath === 'entry/src/main/cpp/PackageProvider.cpp'
+                                ? renderPackageProviderCpp({
+                                    hasManagedExpoHarmonyPackage,
+                                })
+                                : contents,
             binary,
         };
     }));
@@ -179,7 +192,13 @@ async function buildManagedFiles(loadedProject, identifiers, previousToolkitConf
         rnohCliVersion: constants_1.RNOH_CLI_VERSION,
         bundleName: identifiers.bundleName,
         entryModuleName: identifiers.entryModuleName,
-        capabilities: enabledCapabilities.map((capability) => capability.id),
+        capabilities: enabledCapabilities.map((capability) => ({
+            id: capability.id,
+            packageName: capability.packageName,
+            supportTier: capability.supportTier,
+            runtimeMode: capability.runtimeMode,
+            evidence: { ...capability.evidence },
+        })),
         requestedHarmonyPermissions,
         project: {
             name: loadedProject.expoConfig.name ?? identifiers.appName,
@@ -224,6 +243,34 @@ async function buildManagedFiles(loadedProject, identifiers, previousToolkitConf
                 },
             ]
             : []),
+        ...(hasManagedExpoHarmonyPackage
+            ? [
+                {
+                    relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'cpp', 'expoHarmony', 'ExpoHarmonyPackage.h'),
+                    contents: renderExpoHarmonyCppPackage(),
+                },
+                {
+                    relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'expoHarmony', 'ExpoHarmonyPackage.ets'),
+                    contents: renderExpoHarmonyPackage(),
+                },
+                {
+                    relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'expoHarmony', 'ExpoHarmonyFileSystemTurboModule.ts'),
+                    contents: renderExpoHarmonyFileSystemTurboModule(),
+                },
+                {
+                    relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'expoHarmony', 'ExpoHarmonyImagePickerTurboModule.ts'),
+                    contents: renderExpoHarmonyImagePickerTurboModule(),
+                },
+                {
+                    relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'expoHarmony', 'ExpoHarmonyLocationTurboModule.ts'),
+                    contents: renderExpoHarmonyLocationTurboModule(),
+                },
+                {
+                    relativePath: path_1.default.join('harmony', 'entry', 'src', 'main', 'ets', 'expoHarmony', 'ExpoHarmonyCameraTurboModule.ts'),
+                    contents: renderExpoHarmonyCameraTurboModule(),
+                },
+            ]
+            : []),
         {
             relativePath: path_1.default.join(constants_1.GENERATED_DIR, constants_1.TOOLKIT_CONFIG_FILENAME),
             contents: JSON.stringify(toolkitConfig, null, 2) + '\n',
@@ -669,11 +716,17 @@ function getHarmonyPermissionReasonValue(permissionName) {
     switch (permissionName) {
         case 'ohos.permission.CAMERA':
             return 'Camera access is required for Harmony preview image capture flows.';
+        case 'ohos.permission.MICROPHONE':
+            return 'Microphone access is required for Harmony preview video recording flows.';
         case 'ohos.permission.READ_IMAGEVIDEO':
             return 'Media library access is required for Harmony preview image selection flows.';
         case 'ohos.permission.LOCATION':
         case 'ohos.permission.APPROXIMATELY_LOCATION':
             return 'Location access is required for Harmony preview location flows.';
+        case 'ohos.permission.LOCATION_IN_BACKGROUND':
+            return 'Background location access is required for Harmony preview background location flows.';
+        case 'ohos.permission.ACCELEROMETER':
+            return 'Motion sensor access is required for Harmony preview heading flows.';
         case 'ohos.permission.NOTIFICATION_CONTROLLER':
             return 'Notification access is required for Harmony preview notification flows.';
         default:
@@ -683,6 +736,7 @@ function getHarmonyPermissionReasonValue(permissionName) {
 function getHarmonyPermissionWhen(permissionName) {
     switch (permissionName) {
         case 'ohos.permission.NOTIFICATION_CONTROLLER':
+        case 'ohos.permission.LOCATION_IN_BACKGROUND':
             return 'always';
         default:
             return 'inuse';
@@ -711,16 +765,299 @@ function renderEntryStringResources(appDescription, appName, requestedHarmonyPer
         string: stringEntries,
     }, null, 2) + '\n';
 }
+function renderPackageProvider(options) {
+    const managedImports = options.hasManagedExpoHarmonyPackage
+        ? "import { ExpoHarmonyPackage } from './expoHarmony/ExpoHarmonyPackage';\n"
+        : '';
+    const managedPackages = options.hasManagedExpoHarmonyPackage ? ', new ExpoHarmonyPackage(ctx)' : '';
+    return `import type { RNPackageContext, RNPackage } from '@rnoh/react-native-openharmony';
+import { createRNOHPackages as createRNOHPackagesAutolinking } from './RNOHPackagesFactory';
+${managedImports}
+export function getRNOHPackages(ctx: RNPackageContext): RNPackage[] {
+  return [...createRNOHPackagesAutolinking(ctx)${managedPackages}];
+}
+`;
+}
+function renderPackageProviderCpp(options) {
+    const managedInclude = options.hasManagedExpoHarmonyPackage
+        ? '#include "expoHarmony/ExpoHarmonyPackage.h"\n'
+        : '';
+    const managedPackage = options.hasManagedExpoHarmonyPackage
+        ? '  packages.push_back(std::make_shared<ExpoHarmonyPackage>(ctx));\n'
+        : '';
+    return `#include "RNOH/PackageProvider.h"
+#include "RNOHPackagesFactory.h"
+#include "generated/RNOHGeneratedPackage.h"
+${managedInclude}
+using namespace rnoh;
+
+std::vector<std::shared_ptr<Package>> PackageProvider::getPackages(
+    Package::Context ctx) {
+  auto packages = createRNOHPackages(ctx);
+  packages.push_back(std::make_shared<RNOHGeneratedPackage>(ctx));
+${managedPackage}  return packages;
+}
+`;
+}
+function renderExpoHarmonyCppPackage() {
+    return `#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "RNOH/ArkTSTurboModule.h"
+#include "RNOH/Package.h"
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+using namespace facebook;
+
+inline constexpr char ExpoHarmonyCameraViewComponentName[] =
+    "ExpoHarmonyCameraView";
+using ExpoHarmonyCameraViewShadowNode =
+    react::ConcreteViewShadowNode<ExpoHarmonyCameraViewComponentName>;
+using ExpoHarmonyCameraViewComponentDescriptor =
+    react::ConcreteComponentDescriptor<ExpoHarmonyCameraViewShadowNode>;
+
+static jsi::Value __hostFunction_ExpoHarmonyFileSystemTurboModule_getConstants(
+    jsi::Runtime& rt,
+    react::TurboModule& turboModule,
+    const jsi::Value* args,
+    size_t count) {
+  return static_cast<ArkTSTurboModule&>(turboModule)
+      .call(rt, "getConstants", args, count);
+}
+
+static jsi::Value __hostFunction_ExpoHarmonyImagePickerTurboModule_getConstants(
+    jsi::Runtime& rt,
+    react::TurboModule& turboModule,
+    const jsi::Value* args,
+    size_t count) {
+  return static_cast<ArkTSTurboModule&>(turboModule)
+      .call(rt, "getConstants", args, count);
+}
+
+static jsi::Value __hostFunction_ExpoHarmonyLocationTurboModule_getConstants(
+    jsi::Runtime& rt,
+    react::TurboModule& turboModule,
+    const jsi::Value* args,
+    size_t count) {
+  return static_cast<ArkTSTurboModule&>(turboModule)
+      .call(rt, "getConstants", args, count);
+}
+
+static jsi::Value __hostFunction_ExpoHarmonyCameraTurboModule_getConstants(
+    jsi::Runtime& rt,
+    react::TurboModule& turboModule,
+    const jsi::Value* args,
+    size_t count) {
+  return static_cast<ArkTSTurboModule&>(turboModule)
+      .call(rt, "getConstants", args, count);
+}
+
+class JSI_EXPORT ExpoHarmonyFileSystemTurboModule : public ArkTSTurboModule {
+ public:
+  ExpoHarmonyFileSystemTurboModule(
+      const ArkTSTurboModule::Context ctx,
+      const std::string name)
+      : ArkTSTurboModule(ctx, name) {
+    methodMap_["getConstants"] = MethodMetadata{
+        0, __hostFunction_ExpoHarmonyFileSystemTurboModule_getConstants};
+    methodMap_["getInfo"] = MethodMetadata{2, ARK_ASYNC_METHOD_CALLER(getInfo)};
+    methodMap_["readAsString"] = MethodMetadata{
+        2, ARK_ASYNC_METHOD_CALLER(readAsString)};
+    methodMap_["writeAsString"] = MethodMetadata{
+        3, ARK_ASYNC_METHOD_CALLER(writeAsString)};
+    methodMap_["deletePath"] = MethodMetadata{
+        2, ARK_ASYNC_METHOD_CALLER(deletePath)};
+    methodMap_["makeDirectory"] = MethodMetadata{
+        2, ARK_ASYNC_METHOD_CALLER(makeDirectory)};
+    methodMap_["readDirectory"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(readDirectory)};
+    methodMap_["copy"] = MethodMetadata{2, ARK_ASYNC_METHOD_CALLER(copy)};
+    methodMap_["move"] = MethodMetadata{2, ARK_ASYNC_METHOD_CALLER(move)};
+    methodMap_["download"] = MethodMetadata{
+        3, ARK_ASYNC_METHOD_CALLER(download)};
+  }
+};
+
+class JSI_EXPORT ExpoHarmonyImagePickerTurboModule : public ArkTSTurboModule {
+ public:
+  ExpoHarmonyImagePickerTurboModule(
+      const ArkTSTurboModule::Context ctx,
+      const std::string name)
+      : ArkTSTurboModule(ctx, name) {
+    methodMap_["getConstants"] = MethodMetadata{
+        0, __hostFunction_ExpoHarmonyImagePickerTurboModule_getConstants};
+    methodMap_["getMediaLibraryPermissionStatus"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(getMediaLibraryPermissionStatus)};
+    methodMap_["requestMediaLibraryPermission"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(requestMediaLibraryPermission)};
+    methodMap_["getCameraPermissionStatus"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(getCameraPermissionStatus)};
+    methodMap_["requestCameraPermission"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(requestCameraPermission)};
+    methodMap_["launchImageLibrary"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(launchImageLibrary)};
+    methodMap_["launchCamera"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(launchCamera)};
+    methodMap_["getPendingResult"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(getPendingResult)};
+  }
+};
+
+class JSI_EXPORT ExpoHarmonyLocationTurboModule : public ArkTSTurboModule {
+ public:
+  ExpoHarmonyLocationTurboModule(
+      const ArkTSTurboModule::Context ctx,
+      const std::string name)
+      : ArkTSTurboModule(ctx, name) {
+    methodMap_["getConstants"] = MethodMetadata{
+        0, __hostFunction_ExpoHarmonyLocationTurboModule_getConstants};
+    methodMap_["getForegroundPermissionStatus"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(getForegroundPermissionStatus)};
+    methodMap_["requestForegroundPermission"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(requestForegroundPermission)};
+    methodMap_["getBackgroundPermissionStatus"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(getBackgroundPermissionStatus)};
+    methodMap_["requestBackgroundPermission"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(requestBackgroundPermission)};
+    methodMap_["hasServicesEnabled"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(hasServicesEnabled)};
+    methodMap_["getProviderStatus"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(getProviderStatus)};
+    methodMap_["getCurrentPosition"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(getCurrentPosition)};
+    methodMap_["getLastKnownPosition"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(getLastKnownPosition)};
+    methodMap_["geocode"] = MethodMetadata{1, ARK_ASYNC_METHOD_CALLER(geocode)};
+    methodMap_["reverseGeocode"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(reverseGeocode)};
+    methodMap_["startWatchPosition"] = MethodMetadata{
+        2, ARK_ASYNC_METHOD_CALLER(startWatchPosition)};
+    methodMap_["stopWatchPosition"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(stopWatchPosition)};
+    methodMap_["getHeading"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(getHeading)};
+    methodMap_["startWatchHeading"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(startWatchHeading)};
+    methodMap_["stopWatchHeading"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(stopWatchHeading)};
+  }
+};
+
+class JSI_EXPORT ExpoHarmonyCameraTurboModule : public ArkTSTurboModule {
+ public:
+  ExpoHarmonyCameraTurboModule(
+      const ArkTSTurboModule::Context ctx,
+      const std::string name)
+      : ArkTSTurboModule(ctx, name) {
+    methodMap_["getConstants"] = MethodMetadata{
+        0, __hostFunction_ExpoHarmonyCameraTurboModule_getConstants};
+    methodMap_["getCameraPermissionStatus"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(getCameraPermissionStatus)};
+    methodMap_["requestCameraPermission"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(requestCameraPermission)};
+    methodMap_["getMicrophonePermissionStatus"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(getMicrophonePermissionStatus)};
+    methodMap_["requestMicrophonePermission"] = MethodMetadata{
+        0, ARK_ASYNC_METHOD_CALLER(requestMicrophonePermission)};
+    methodMap_["createPreview"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(createPreview)};
+    methodMap_["disposePreview"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(disposePreview)};
+    methodMap_["pausePreview"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(pausePreview)};
+    methodMap_["resumePreview"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(resumePreview)};
+    methodMap_["takePicture"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(takePicture)};
+    methodMap_["startRecording"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(startRecording)};
+    methodMap_["stopRecording"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(stopRecording)};
+    methodMap_["toggleRecording"] = MethodMetadata{
+        1, ARK_ASYNC_METHOD_CALLER(toggleRecording)};
+  }
+};
+
+class ExpoHarmonyTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+ public:
+  SharedTurboModule createTurboModule(Context ctx, const std::string& name)
+      const override {
+    if (name == "ExpoHarmonyFileSystem") {
+      return std::make_shared<ExpoHarmonyFileSystemTurboModule>(ctx, name);
+    }
+    if (name == "ExpoHarmonyImagePicker") {
+      return std::make_shared<ExpoHarmonyImagePickerTurboModule>(ctx, name);
+    }
+    if (name == "ExpoHarmonyLocation") {
+      return std::make_shared<ExpoHarmonyLocationTurboModule>(ctx, name);
+    }
+    if (name == "ExpoHarmonyCamera") {
+      return std::make_shared<ExpoHarmonyCameraTurboModule>(ctx, name);
+    }
+
+    return nullptr;
+  }
+};
+
+class ExpoHarmonyCameraViewJSIBinder : public ViewComponentJSIBinder {
+ protected:
+  facebook::jsi::Object createNativeProps(facebook::jsi::Runtime& rt) override {
+    auto nativeProps = ViewComponentJSIBinder::createNativeProps(rt);
+    nativeProps.setProperty(rt, "viewId", "string");
+    nativeProps.setProperty(rt, "facing", "string");
+    nativeProps.setProperty(rt, "mode", "string");
+    return nativeProps;
+  }
+};
+
+class ExpoHarmonyPackage : public Package {
+ public:
+  explicit ExpoHarmonyPackage(Package::Context ctx) : Package(ctx) {}
+
+  std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate()
+      override {
+    return std::make_unique<ExpoHarmonyTurboModuleFactoryDelegate>();
+  }
+
+  std::vector<facebook::react::ComponentDescriptorProvider>
+  createComponentDescriptorProviders() override {
+    return {
+        facebook::react::concreteComponentDescriptorProvider<
+            ExpoHarmonyCameraViewComponentDescriptor>(),
+    };
+  }
+
+  ComponentJSIBinderByString createComponentJSIBinderByName() override {
+    auto binder = std::make_shared<ExpoHarmonyCameraViewJSIBinder>();
+    return {
+        {"ExpoHarmonyCameraView", binder},
+    };
+  }
+};
+} // namespace rnoh
+`;
+}
 function renderCapabilityModuleShim(capability) {
     switch (capability.packageName) {
         case 'expo-file-system':
-            return renderExpoFileSystemPreviewShim(capability);
+            return capability.runtimeMode !== 'shim'
+                ? renderExpoFileSystemHarmonyAdapterShim(capability)
+                : renderExpoFileSystemPreviewShim(capability);
         case 'expo-image-picker':
-            return renderExpoImagePickerPreviewShim(capability);
+            return capability.runtimeMode !== 'shim'
+                ? renderExpoImagePickerHarmonyAdapterShim(capability)
+                : renderExpoImagePickerPreviewShim(capability);
         case 'expo-location':
-            return renderExpoLocationPreviewShim(capability);
+            return capability.runtimeMode !== 'shim'
+                ? renderExpoLocationHarmonyAdapterShim(capability)
+                : renderExpoLocationPreviewShim(capability);
         case 'expo-camera':
-            return renderExpoCameraPreviewShim(capability);
+            return capability.runtimeMode !== 'shim'
+                ? renderExpoCameraHarmonyAdapterShim(capability)
+                : renderExpoCameraPreviewShim(capability);
         default:
             return renderUnsupportedCapabilityShim(capability);
     }
@@ -963,199 +1300,2839 @@ module.exports = new Proxy(
 );
 `;
 }
-function renderExpoFileSystemPreviewShim(capability) {
-    return `'use strict';
-
-const { CodedError } = require('expo-modules-core');
+function renderExpoHarmonyPackage() {
+    return `import type {
+  AnyThreadTurboModule,
+  AnyThreadTurboModuleContext,
+  UITurboModule,
+  UITurboModuleContext,
+} from '@rnoh/react-native-openharmony';
+import {
+  RNOHPackage,
+} from '@rnoh/react-native-openharmony';
+import { ExpoHarmonyFileSystemTurboModule } from './ExpoHarmonyFileSystemTurboModule';
+import { ExpoHarmonyImagePickerTurboModule } from './ExpoHarmonyImagePickerTurboModule';
+import { ExpoHarmonyLocationTurboModule } from './ExpoHarmonyLocationTurboModule';
+import { ExpoHarmonyCameraTurboModule } from './ExpoHarmonyCameraTurboModule';
+
+export class ExpoHarmonyPackage extends RNOHPackage {
+  override getAnyThreadTurboModuleFactoryByNameMap(): Map<
+    string,
+    (ctx: AnyThreadTurboModuleContext) => AnyThreadTurboModule | null
+  > {
+    return new Map<string, (ctx: AnyThreadTurboModuleContext) => AnyThreadTurboModule | null>()
+      .set(
+        ExpoHarmonyFileSystemTurboModule.NAME,
+        (ctx) => new ExpoHarmonyFileSystemTurboModule(ctx),
+      )
+      .set(
+        ExpoHarmonyLocationTurboModule.NAME,
+        (ctx) => new ExpoHarmonyLocationTurboModule(ctx),
+      );
+  }
 
-const PREVIEW_MESSAGE =
-  '${capability.packageName} is routed through the Expo Harmony ${capability.supportTier} bridge. Bundling is supported, but runtime file-system behavior is not verified yet.';
+  override getUITurboModuleFactoryByNameMap(): Map<
+    string,
+    (ctx: UITurboModuleContext) => UITurboModule | null
+  > {
+    return new Map<string, (ctx: UITurboModuleContext) => UITurboModule | null>()
+      .set(
+        ExpoHarmonyImagePickerTurboModule.NAME,
+        (ctx) => new ExpoHarmonyImagePickerTurboModule(ctx),
+      )
+      .set(
+        ExpoHarmonyCameraTurboModule.NAME,
+        (ctx) => new ExpoHarmonyCameraTurboModule(ctx),
+      );
+  }
 
-function createPreviewError(operationName) {
-  return new CodedError(
-    'ERR_EXPO_HARMONY_PREVIEW',
-    PREVIEW_MESSAGE + ' Attempted operation: ' + operationName + '.',
-  );
+  override getDebugName() {
+    return 'expo-harmony';
+  }
 }
-
-async function unavailable(operationName) {
-  throw createPreviewError(operationName);
+`;
 }
+function renderExpoHarmonyFileSystemTurboModule() {
+    return `import fs from '@ohos.file.fs';
+import { AnyThreadTurboModuleContext, AnyThreadTurboModule } from '@rnoh/react-native-openharmony/ts';
 
-module.exports = {
-  cacheDirectory: 'file:///expo-harmony/cache/',
-  documentDirectory: 'file:///expo-harmony/document/',
-  bundleDirectory: 'file:///expo-harmony/bundle/',
-  EncodingType: {
-    UTF8: 'utf8',
-    Base64: 'base64',
-  },
-  FileSystemSessionType: {
-    BACKGROUND: 0,
-    FOREGROUND: 1,
-  },
-  getInfoAsync(path) {
-    return unavailable('getInfoAsync(' + String(path) + ')');
-  },
-  readAsStringAsync(path) {
-    return unavailable('readAsStringAsync(' + String(path) + ')');
-  },
-  writeAsStringAsync(path) {
-    return unavailable('writeAsStringAsync(' + String(path) + ')');
-  },
-  deleteAsync(path) {
-    return unavailable('deleteAsync(' + String(path) + ')');
-  },
-  makeDirectoryAsync(path) {
-    return unavailable('makeDirectoryAsync(' + String(path) + ')');
-  },
-  readDirectoryAsync(path) {
-    return unavailable('readDirectoryAsync(' + String(path) + ')');
-  },
-  copyAsync(options) {
-    return unavailable('copyAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-  moveAsync(options) {
-    return unavailable('moveAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-  downloadAsync(url) {
-    return unavailable('downloadAsync(' + String(url) + ')');
-  },
+type FileInfoOptions = {
+  md5?: boolean;
 };
-`;
-}
-function renderExpoImagePickerPreviewShim(capability) {
-    return `'use strict';
 
-const { CodedError } = require('expo-modules-core');
+type WriteOptions = {
+  encoding?: string;
+  append?: boolean;
+};
 
-const PREVIEW_MESSAGE =
-  '${capability.packageName} is routed through the Expo Harmony ${capability.supportTier} bridge. Bundling is supported, but picker and camera flows still need device-side validation.';
+type ReadOptions = {
+  encoding?: string;
+  position?: number;
+  length?: number;
+};
 
-function createPreviewError(operationName) {
-  return new CodedError(
-    'ERR_EXPO_HARMONY_PREVIEW',
-    PREVIEW_MESSAGE + ' Attempted operation: ' + operationName + '.',
-  );
-}
+type MakeDirectoryOptions = {
+  intermediates?: boolean;
+};
 
-async function unavailable(operationName) {
-  throw createPreviewError(operationName);
-}
+type DeleteOptions = {
+  idempotent?: boolean;
+};
 
-module.exports = {
-  MediaTypeOptions: {
-    All: 'All',
-    Images: 'Images',
-    Videos: 'Videos',
-  },
-  UIImagePickerPresentationStyle: {
-    AUTOMATIC: 'automatic',
-    FULL_SCREEN: 'fullScreen',
-    PAGE_SHEET: 'pageSheet',
-    FORM_SHEET: 'formSheet',
-    CURRENT_CONTEXT: 'currentContext',
-    OVER_FULL_SCREEN: 'overFullScreen',
-  },
-  requestCameraPermissionsAsync() {
-    return unavailable('requestCameraPermissionsAsync');
-  },
-  requestMediaLibraryPermissionsAsync() {
-    return unavailable('requestMediaLibraryPermissionsAsync');
-  },
-  getCameraPermissionsAsync() {
-    return unavailable('getCameraPermissionsAsync');
-  },
-  getMediaLibraryPermissionsAsync() {
-    return unavailable('getMediaLibraryPermissionsAsync');
-  },
-  launchCameraAsync(options) {
-    return unavailable('launchCameraAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-  launchImageLibraryAsync(options) {
-    return unavailable('launchImageLibraryAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
+type FileInfoResult = {
+  exists: boolean;
+  path: string;
+  isDirectory: boolean;
+  size?: number;
+  modificationTime?: number;
+  md5?: string;
 };
-`;
-}
-function renderExpoLocationPreviewShim(capability) {
-    return `'use strict';
 
-const { CodedError } = require('expo-modules-core');
+type DownloadOptions = {
+  headers?: Record<string, string>;
+  md5?: boolean;
+};
 
-const PREVIEW_MESSAGE =
-  '${capability.packageName} is routed through the Expo Harmony ${capability.supportTier} bridge. Bundling is supported, but foreground permission, current-position, and watch flows still need device-side validation.';
-const DEFAULT_PERMISSION_RESPONSE = {
-  status: 'undetermined',
-  granted: false,
-  canAskAgain: true,
-  expires: 'never',
+type DownloadResult = {
+  uri: string;
+  status: number;
+  headers: Record<string, string>;
+  md5?: string;
 };
 
-function createPreviewError(operationName) {
-  return new CodedError(
-    'ERR_EXPO_HARMONY_PREVIEW',
-    PREVIEW_MESSAGE + ' Attempted operation: ' + operationName + '.',
-  );
-}
+export class ExpoHarmonyFileSystemTurboModule extends AnyThreadTurboModule {
+  public static readonly NAME = 'ExpoHarmonyFileSystem';
 
-async function unavailable(operationName) {
-  throw createPreviewError(operationName);
-}
+  public constructor(ctx: AnyThreadTurboModuleContext) {
+    super(ctx);
+    this.ensureManagedDirectoriesSync();
+  }
 
-function getPermissionResponse() {
-  return { ...DEFAULT_PERMISSION_RESPONSE };
-}
+  getConstants(): {
+    documentDirectoryPath: string;
+    cacheDirectoryPath: string;
+    bundleDirectoryPath: string | null;
+  } {
+    const abilityContext = this.ctx.uiAbilityContext as {
+      bundleCodeDir?: string;
+    };
 
-module.exports = {
-  Accuracy: {
-    Lowest: 1,
-    Low: 2,
-    Balanced: 3,
-    High: 4,
-    Highest: 5,
-    BestForNavigation: 6,
-  },
-  PermissionStatus: {
-    DENIED: 'denied',
-    GRANTED: 'granted',
-    UNDETERMINED: 'undetermined',
-  },
-  requestForegroundPermissionsAsync() {
-    return unavailable('requestForegroundPermissionsAsync');
-  },
-  getForegroundPermissionsAsync() {
-    return Promise.resolve(getPermissionResponse());
-  },
-  requestBackgroundPermissionsAsync() {
-    return unavailable('requestBackgroundPermissionsAsync');
-  },
-  getBackgroundPermissionsAsync() {
-    return Promise.resolve(getPermissionResponse());
-  },
-  hasServicesEnabledAsync() {
-    return Promise.resolve(false);
-  },
-  getCurrentPositionAsync(options) {
-    return unavailable('getCurrentPositionAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-  getLastKnownPositionAsync(options) {
-    return unavailable('getLastKnownPositionAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-  watchPositionAsync(options) {
-    return unavailable('watchPositionAsync(' + JSON.stringify(options ?? {}) + ')');
-  },
-};
-`;
-}
-function renderExpoCameraPreviewShim(capability) {
-    return `'use strict';
+    return {
+      documentDirectoryPath: this.documentDirectoryPath,
+      cacheDirectoryPath: this.cacheDirectoryPath,
+      bundleDirectoryPath:
+        typeof abilityContext.bundleCodeDir === 'string' && abilityContext.bundleCodeDir.length > 0
+          ? abilityContext.bundleCodeDir
+          : null,
+    };
+  }
 
-const React = require('react');
-const { Text, View } = require('react-native');
-const { CodedError } = require('expo-modules-core');
+  async getInfo(path: string, options?: FileInfoOptions): Promise<FileInfoResult> {
+    const normalizedPath = this.normalizeSandboxPath(path);
+    const stat = await this.getStatOrNull(normalizedPath);
 
-const PREVIEW_MESSAGE =
+    if (!stat) {
+      return {
+        exists: false,
+        path: normalizedPath,
+        isDirectory: false,
+      };
+    }
+
+    return {
+      exists: true,
+      path: normalizedPath,
+      isDirectory: stat.isDirectory(),
+      size: Number(stat.size),
+      modificationTime: Number(stat.mtime),
+      md5:
+        options?.md5 === true && !stat.isDirectory()
+          ? this.computePreviewDigest(await this.readFileBytes(normalizedPath))
+          : undefined,
+    };
+  }
+
+  async readAsString(path: string, options?: ReadOptions): Promise<string> {
+    const normalizedPath = this.normalizeSandboxPath(path);
+    const encoding = options?.encoding ?? 'utf8';
+    const bytes = await this.readFileBytes(normalizedPath);
+    const position = typeof options?.position === 'number' && options.position > 0
+      ? Math.floor(options.position)
+      : 0;
+    const length = typeof options?.length === 'number' && options.length >= 0
+      ? Math.floor(options.length)
+      : bytes.length - position;
+    const slicedBytes = bytes.slice(position, position + length);
+
+    if (encoding === 'base64') {
+      return this.encodeBase64(slicedBytes);
+    }
+
+    return this.decodeUtf8(slicedBytes);
+  }
+
+  async writeAsString(path: string, contents: string, options?: WriteOptions): Promise<void> {
+    const normalizedPath = this.normalizeSandboxPath(path);
+    const encoding = options?.encoding ?? 'utf8';
+
+    await this.ensureParentDirectory(normalizedPath);
+
+    const file = await fs.open(
+      normalizedPath,
+      fs.OpenMode.READ_WRITE |
+        fs.OpenMode.CREATE |
+        (options?.append === true ? fs.OpenMode.APPEND : fs.OpenMode.TRUNC),
+    );
+
+    try {
+      if (encoding === 'base64') {
+        await fs.write(file.fd, this.decodeBase64(contents).buffer);
+      } else {
+        await fs.write(file.fd, contents);
+      }
+    } finally {
+      await fs.close(file);
+    }
+  }
+
+  async deletePath(path: string, options?: DeleteOptions): Promise<void> {
+    const normalizedPath = this.normalizeSandboxPath(path);
+    await this.deleteInternal(normalizedPath, options?.idempotent === true);
+  }
+
+  async makeDirectory(path: string, options?: MakeDirectoryOptions): Promise<void> {
+    const normalizedPath = this.normalizeSandboxPath(path);
+    await fs.mkdir(normalizedPath, options?.intermediates === true);
+  }
+
+  async readDirectory(path: string): Promise<string[]> {
+    const normalizedPath = this.normalizeSandboxPath(path);
+    const stat = await fs.stat(normalizedPath);
+
+    if (!stat.isDirectory()) {
+      throw new Error('readDirectory expects a directory path.');
+    }
+
+    return fs.listFile(normalizedPath);
+  }
+
+  async copy(from: string, to: string): Promise<void> {
+    const fromPath = this.normalizeSandboxPath(from);
+    const toPath = this.normalizeSandboxPath(to);
+    await this.copyInternal(fromPath, toPath);
+  }
+
+  async move(from: string, to: string): Promise<void> {
+    const fromPath = this.normalizeSandboxPath(from);
+    const toPath = this.normalizeSandboxPath(to);
+    const stat = await fs.stat(fromPath);
+
+    await this.ensureParentDirectory(toPath);
+
+    if (stat.isDirectory()) {
+      await this.copyInternal(fromPath, toPath);
+      await this.deleteInternal(fromPath, false);
+      return;
+    }
+
+    await fs.moveFile(fromPath, toPath);
+  }
+
+  async download(url: string, destinationPath: string, options?: DownloadOptions): Promise<DownloadResult> {
+    const normalizedDestinationPath = this.normalizeSandboxPath(destinationPath);
+    await this.ensureParentDirectory(normalizedDestinationPath);
+
+    const response = await fetch(url, {
+      headers: options?.headers ?? {},
+    });
+    const responseBuffer = new Uint8Array(await response.arrayBuffer());
+    const file = await fs.open(
+      normalizedDestinationPath,
+      fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE | fs.OpenMode.TRUNC,
+    );
+
+    try {
+      await fs.write(file.fd, responseBuffer.buffer);
+    } finally {
+      await fs.close(file);
+    }
+
+    return {
+      uri: normalizedDestinationPath,
+      status: Number(response.status ?? 200),
+      headers: {},
+      md5: options?.md5 === true ? this.computePreviewDigest(responseBuffer) : undefined,
+    };
+  }
+
+  private get documentDirectoryPath(): string {
+    return \`\${this.ctx.uiAbilityContext.filesDir}/expo-harmony/document\`;
+  }
+
+  private get cacheDirectoryPath(): string {
+    return \`\${this.ctx.uiAbilityContext.cacheDir}/expo-harmony/cache\`;
+  }
+
+  private ensureManagedDirectoriesSync(): void {
+    this.ensureDirectorySync(this.documentDirectoryPath);
+    this.ensureDirectorySync(this.cacheDirectoryPath);
+  }
+
+  private ensureDirectorySync(directoryPath: string): void {
+    if (!fs.accessSync(directoryPath)) {
+      fs.mkdirSync(directoryPath, true);
+    }
+  }
+
+  private async ensureParentDirectory(targetPath: string): Promise<void> {
+    const parentPath = this.getParentPath(targetPath);
+
+    if (!parentPath) {
+      return;
+    }
+
+    const parentStat = await this.getStatOrNull(parentPath);
+
+    if (parentStat) {
+      if (!parentStat.isDirectory()) {
+        throw new Error(\`Expected parent path to be a directory: \${parentPath}\`);
+      }
+
+      return;
+    }
+
+    await fs.mkdir(parentPath, true);
+  }
+
+  private getParentPath(targetPath: string): string | null {
+    let normalizedPath = targetPath;
+
+    while (normalizedPath.length > 1 && normalizedPath.endsWith('/')) {
+      normalizedPath = normalizedPath.slice(0, -1);
+    }
+    const slashIndex = normalizedPath.lastIndexOf('/');
+
+    if (slashIndex <= 0) {
+      return null;
+    }
+
+    return normalizedPath.slice(0, slashIndex);
+  }
+
+  private async deleteInternal(targetPath: string, idempotent: boolean): Promise<void> {
+    const stat = await this.getStatOrNull(targetPath);
+
+    if (!stat) {
+      if (idempotent) {
+        return;
+      }
+
+      throw new Error(\`No file or directory exists at \${targetPath}.\`);
+    }
+
+    if (stat.isDirectory()) {
+      const entries = await fs.listFile(targetPath);
+
+      for (const entryName of entries) {
+        await this.deleteInternal(\`\${targetPath}/\${entryName}\`, idempotent);
+      }
+
+      await fs.rmdir(targetPath);
+      return;
+    }
+
+    await fs.unlink(targetPath);
+  }
+
+  private async copyInternal(fromPath: string, toPath: string): Promise<void> {
+    const stat = await fs.stat(fromPath);
+
+    await this.ensureParentDirectory(toPath);
+
+    if (stat.isDirectory()) {
+      await fs.mkdir(toPath, true);
+      const entries = await fs.listFile(fromPath);
+
+      for (const entryName of entries) {
+        await this.copyInternal(\`\${fromPath}/\${entryName}\`, \`\${toPath}/\${entryName}\`);
+      }
+
+      return;
+    }
+
+    await fs.copyFile(fromPath, toPath);
+  }
+
+  private async getStatOrNull(targetPath: string): Promise<fs.Stat | null> {
+    try {
+      return await fs.stat(targetPath);
+    } catch (error) {
+      if (this.isNoSuchFileError(error)) {
+        return null;
+      }
+
+      throw error;
+    }
+  }
+
+  private isNoSuchFileError(error: unknown): boolean {
+    return (
+      typeof error === 'object' &&
+      error !== null &&
+      'code' in error &&
+      Number((error as { code?: number }).code) === 13900002
+    );
+  }
+
+  private async readFileBytes(targetPath: string): Promise<Uint8Array> {
+    const stat = await fs.stat(targetPath);
+    const file = await fs.open(targetPath, fs.OpenMode.READ_ONLY);
+    const buffer = new ArrayBuffer(Number(stat.size ?? 0));
+
+    try {
+      await fs.read(file.fd, buffer);
+      return new Uint8Array(buffer);
+    } finally {
+      await fs.close(file);
+    }
+  }
+
+  private decodeUtf8(bytes: Uint8Array): string {
+    return new TextDecoder().decode(bytes);
+  }
+
+  private encodeBase64(bytes: Uint8Array): string {
+    let binary = '';
+
+    for (const byte of bytes) {
+      binary += String.fromCharCode(byte);
+    }
+
+    return btoa(binary);
+  }
+
+  private decodeBase64(contents: string): Uint8Array {
+    const binary = atob(contents);
+    const bytes = new Uint8Array(binary.length);
+
+    for (let index = 0; index < binary.length; index += 1) {
+      bytes[index] = binary.charCodeAt(index);
+    }
+
+    return bytes;
+  }
+
+  private computePreviewDigest(bytes: Uint8Array): string {
+    let hash = 2166136261;
+
+    for (const byte of bytes) {
+      hash ^= byte;
+      hash = Math.imul(hash, 16777619);
+    }
+
+    return String(hash >>> 0).padStart(32, '0').slice(-32);
+  }
+
+  private normalizeSandboxPath(inputPath: string): string {
+    if (typeof inputPath !== 'string' || inputPath.length === 0) {
+      throw new Error('ExpoHarmonyFileSystem expected a non-empty sandbox path.');
+    }
+
+    if (!inputPath.startsWith('/')) {
+      throw new Error('ExpoHarmonyFileSystem accepts only absolute sandbox paths.');
+    }
+
+    if (inputPath.includes('/../') || inputPath.endsWith('/..') || inputPath.includes('/./')) {
+      throw new Error('ExpoHarmonyFileSystem does not accept relative path segments.');
+    }
+
+    const allowedRoots = [
+      this.ctx.uiAbilityContext.filesDir,
+      this.ctx.uiAbilityContext.cacheDir,
+    ].filter((value): value is string => typeof value === 'string' && value.length > 0);
+
+    const isAllowed = allowedRoots.some(
+      (rootPath) => inputPath === rootPath || inputPath.startsWith(\`\${rootPath}/\`),
+    );
+
+    if (!isAllowed) {
+      throw new Error('ExpoHarmonyFileSystem accepts only app sandbox paths.');
+    }
+
+    return inputPath;
+  }
+}
+`;
+}
+function renderExpoHarmonyImagePickerTurboModule() {
+    return `import type { Permissions } from '@ohos.abilityAccessCtrl';
+import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
+import photoAccessHelper from '@ohos.file.photoAccessHelper';
+import picker from '@ohos.file.picker';
+import image from '@ohos.multimedia.image';
+import fs from '@ohos.file.fs';
+import { UITurboModuleContext, UITurboModule } from '@rnoh/react-native-openharmony/ts';
+
+type PermissionResponse = {
+  status: 'granted' | 'denied' | 'undetermined';
+  granted: boolean;
+  canAskAgain: boolean;
+  expires: 'never';
+  accessPrivileges?: 'all' | 'limited' | 'none';
+};
+
+type LaunchImageLibraryOptions = {
+  mediaTypes?: string | string[];
+  allowsMultipleSelection?: boolean;
+  selectionLimit?: number;
+};
+
+type LaunchCameraOptions = {
+  mediaTypes?: string | string[];
+  cameraType?: string;
+};
+
+type ImagePickerAsset = {
+  uri: string;
+  assetId: string | null;
+  width: number;
+  height: number;
+  type: 'image' | 'video' | null;
+  fileName: string | null;
+  fileSize: number | null;
+  mimeType: string | null;
+  duration: number | null;
+  exif: null;
+  base64: null;
+};
+
+type ImagePickerResult = {
+  canceled: boolean;
+  assets: ImagePickerAsset[] | null;
+};
+
+export class ExpoHarmonyImagePickerTurboModule extends UITurboModule {
+  public static readonly NAME = 'ExpoHarmonyImagePicker';
+
+  private readonly atManager = abilityAccessCtrl.createAtManager();
+  private pendingResult: ImagePickerResult | null = null;
+
+  getConstants(): Record<string, never> {
+    return {};
+  }
+
+  async getMediaLibraryPermissionStatus(_writeOnly?: boolean): Promise<PermissionResponse> {
+    return this.getPermissionResponse('ohos.permission.READ_IMAGEVIDEO', true);
+  }
+
+  async requestMediaLibraryPermission(_writeOnly?: boolean): Promise<PermissionResponse> {
+    return this.requestPermissionResponse('ohos.permission.READ_IMAGEVIDEO', true);
+  }
+
+  async getCameraPermissionStatus(): Promise<PermissionResponse> {
+    return this.getPermissionResponse('ohos.permission.CAMERA', false);
+  }
+
+  async requestCameraPermission(): Promise<PermissionResponse> {
+    return this.requestPermissionResponse('ohos.permission.CAMERA', false);
+  }
+
+  async launchImageLibrary(options?: LaunchImageLibraryOptions): Promise<ImagePickerResult> {
+    await this.ensurePermissionGranted('ohos.permission.READ_IMAGEVIDEO', true);
+
+    const photoPicker = new photoAccessHelper.PhotoViewPicker();
+    const selection = await photoPicker.select(this.createPhotoSelectOptions(options));
+    let selectedUris = this.normalizeSelectedUris(selection?.photoUris);
+
+    if (selectedUris.length === 0) {
+      selectedUris = await this.launchLegacyPhotoPicker(options);
+    }
+
+    if (selectedUris.length === 0) {
+      return this.createCanceledResult();
+    }
+
+    const authorizedUris = await this.requestAuthorizedUris(selectedUris);
+    const assets = await Promise.all(
+      authorizedUris.map((uri, index) =>
+        this.createImagePickerAsset(uri, selectedUris[index] ?? uri, this.inferAssetTypeFromMediaTypes(options?.mediaTypes)),
+      ),
+    );
+
+    const result = {
+      canceled: false,
+      assets,
+    };
+    this.pendingResult = result;
+    return result;
+  }
+
+  async launchCamera(options?: LaunchCameraOptions): Promise<ImagePickerResult> {
+    const requestedAssetType = this.inferAssetTypeFromMediaTypes(options?.mediaTypes);
+
+    await this.ensurePermissionGranted('ohos.permission.CAMERA', false);
+    await this.ensurePermissionGranted('ohos.permission.READ_IMAGEVIDEO', true);
+    if (requestedAssetType === 'video') {
+      await this.ensurePermissionGranted('ohos.permission.MICROPHONE', false);
+    }
+
+    const cameraEntryPicker = new photoAccessHelper.PhotoViewPicker();
+    const selection = await cameraEntryPicker.select(
+      this.createPhotoSelectOptions(
+        {
+          mediaTypes: requestedAssetType === 'video' ? 'videos' : 'images',
+          allowsMultipleSelection: false,
+        },
+        true,
+      ),
+    );
+    const selectedUris = this.normalizeSelectedUris(selection?.photoUris);
+
+    if (selectedUris.length === 0) {
+      return this.createCanceledResult();
+    }
+
+    const authorizedUris = await this.requestAuthorizedUris(selectedUris);
+    const assetUri = authorizedUris[0] ?? selectedUris[0];
+
+    const result = {
+      canceled: false,
+      assets: [await this.createImagePickerAsset(assetUri, selectedUris[0], requestedAssetType ?? 'image')],
+    };
+    this.pendingResult = result;
+    return result;
+  }
+
+  async getPendingResult(): Promise<ImagePickerResult | null> {
+    const result = this.pendingResult;
+    this.pendingResult = null;
+    return result;
+  }
+
+  private async ensurePermissionGranted(
+    permissionName: Permissions,
+    isMediaLibraryPermission: boolean,
+  ): Promise<void> {
+    const permissionResponse = await this.getPermissionResponse(permissionName, isMediaLibraryPermission);
+
+    if (permissionResponse.granted) {
+      return;
+    }
+
+    const requestedResponse = await this.requestPermissionResponse(permissionName, isMediaLibraryPermission);
+
+    if (!requestedResponse.granted) {
+      throw new Error(\`Permission denied for \${permissionName}.\`);
+    }
+  }
+
+  private async getPermissionResponse(
+    permissionName: Permissions,
+    isMediaLibraryPermission: boolean,
+  ): Promise<PermissionResponse> {
+    return this.permissionResponseFromStatus(
+      this.resolvePermissionStatus(permissionName),
+      isMediaLibraryPermission,
+    );
+  }
+
+  private async requestPermissionResponse(
+    permissionName: Permissions,
+    isMediaLibraryPermission: boolean,
+  ): Promise<PermissionResponse> {
+    const requestResult = await this.atManager.requestPermissionsFromUser(
+      this.ctx.uiAbilityContext,
+      [permissionName],
+    );
+    const authResult = Array.isArray(requestResult.authResults)
+      ? Number(requestResult.authResults[0] ?? abilityAccessCtrl.GrantStatus.PERMISSION_DENIED)
+      : abilityAccessCtrl.GrantStatus.PERMISSION_DENIED;
+
+    if (authResult === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
+      return this.permissionResponseFromStatus(
+        abilityAccessCtrl.PermissionStatus.GRANTED,
+        isMediaLibraryPermission,
+      );
+    }
+
+    return this.permissionResponseFromStatus(
+      abilityAccessCtrl.PermissionStatus.DENIED,
+      isMediaLibraryPermission,
+    );
+  }
+
+  private resolvePermissionStatus(permissionName: Permissions): abilityAccessCtrl.PermissionStatus {
+    const atManagerWithSelfStatus = this.atManager as abilityAccessCtrl.AtManager & {
+      getSelfPermissionStatus?: (permission: Permissions) => abilityAccessCtrl.PermissionStatus;
+    };
+
+    if (typeof atManagerWithSelfStatus.getSelfPermissionStatus === 'function') {
+      return atManagerWithSelfStatus.getSelfPermissionStatus(permissionName);
+    }
+
+    const accessTokenId = this.ctx.uiAbilityContext.abilityInfo.applicationInfo.accessTokenId;
+    const grantStatus = this.atManager.checkAccessTokenSync(accessTokenId, permissionName);
+
+    return grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED
+      ? abilityAccessCtrl.PermissionStatus.GRANTED
+      : abilityAccessCtrl.PermissionStatus.NOT_DETERMINED;
+  }
+
+  private permissionResponseFromStatus(
+    permissionStatus: abilityAccessCtrl.PermissionStatus,
+    isMediaLibraryPermission: boolean,
+  ): PermissionResponse {
+    const granted = permissionStatus === abilityAccessCtrl.PermissionStatus.GRANTED;
+    const denied =
+      permissionStatus === abilityAccessCtrl.PermissionStatus.DENIED ||
+      permissionStatus === abilityAccessCtrl.PermissionStatus.RESTRICTED ||
+      permissionStatus === abilityAccessCtrl.PermissionStatus.INVALID;
+
+    return {
+      status: granted ? 'granted' : denied ? 'denied' : 'undetermined',
+      granted,
+      canAskAgain: !denied,
+      expires: 'never',
+      ...(isMediaLibraryPermission
+        ? {
+            accessPrivileges: granted ? 'all' : 'none',
+          }
+        : {}),
+    };
+  }
+
+  private createPhotoSelectOptions(
+    options?: LaunchImageLibraryOptions,
+    isPhotoTakingSupported: boolean = false,
+  ): photoAccessHelper.PhotoSelectOptions {
+    const selectOptions = new photoAccessHelper.PhotoSelectOptions();
+    selectOptions.MIMEType = this.resolvePhotoViewMimeType(options?.mediaTypes);
+    selectOptions.maxSelectNumber =
+      options?.allowsMultipleSelection === true
+        ? this.resolveSelectionLimit(options?.selectionLimit)
+        : 1;
+    selectOptions.isSearchSupported = true;
+    selectOptions.isPhotoTakingSupported = isPhotoTakingSupported;
+    return selectOptions;
+  }
+
+  private async launchLegacyPhotoPicker(options?: LaunchImageLibraryOptions): Promise<string[]> {
+    const legacyPicker = new picker.PhotoViewPicker(this.ctx.uiAbilityContext);
+    const legacyOptions = new picker.PhotoSelectOptions();
+    legacyOptions.MIMEType = this.resolveLegacyPhotoViewMimeType(options?.mediaTypes);
+    legacyOptions.maxSelectNumber =
+      options?.allowsMultipleSelection === true
+        ? this.resolveSelectionLimit(options?.selectionLimit)
+        : 1;
+
+    const selection = await legacyPicker.select(legacyOptions);
+    return this.normalizeSelectedUris(selection?.photoUris);
+  }
+
+  private resolveSelectionLimit(selectionLimit?: number): number {
+    if (typeof selectionLimit === 'number' && Number.isFinite(selectionLimit) && selectionLimit > 0) {
+      return Math.floor(selectionLimit);
+    }
+
+    return 20;
+  }
+
+  private resolvePhotoViewMimeType(
+    rawMediaTypes?: string | string[],
+  ): photoAccessHelper.PhotoViewMIMETypes {
+    const normalized = this.normalizeMediaTypes(rawMediaTypes);
+
+    if (normalized.includes('video') && !normalized.includes('image')) {
+      return photoAccessHelper.PhotoViewMIMETypes.VIDEO_TYPE;
+    }
+
+    if (normalized.includes('video') && normalized.includes('image')) {
+      return photoAccessHelper.PhotoViewMIMETypes.IMAGE_VIDEO_TYPE;
+    }
+
+    return photoAccessHelper.PhotoViewMIMETypes.IMAGE_TYPE;
+  }
+
+  private resolveLegacyPhotoViewMimeType(
+    rawMediaTypes?: string | string[],
+  ): picker.PhotoViewMIMETypes {
+    const normalized = this.normalizeMediaTypes(rawMediaTypes);
+
+    if (normalized.includes('video') && !normalized.includes('image')) {
+      return picker.PhotoViewMIMETypes.VIDEO_TYPE;
+    }
+
+    if (normalized.includes('video') && normalized.includes('image')) {
+      return picker.PhotoViewMIMETypes.IMAGE_VIDEO_TYPE;
+    }
+
+    return picker.PhotoViewMIMETypes.IMAGE_TYPE;
+  }
+
+  private inferAssetTypeFromMediaTypes(
+    rawMediaTypes?: string | string[],
+  ): 'image' | 'video' | null {
+    const normalized = this.normalizeMediaTypes(rawMediaTypes);
+
+    if (normalized.includes('video') && !normalized.includes('image')) {
+      return 'video';
+    }
+
+    if (normalized.includes('image')) {
+      return 'image';
+    }
+
+    return null;
+  }
+
+  private normalizeMediaTypes(rawMediaTypes?: string | string[]): string[] {
+    if (Array.isArray(rawMediaTypes)) {
+      return Array.from(
+        new Set(
+          rawMediaTypes
+            .map((value) => this.normalizeMediaTypeValue(value))
+            .filter((value): value is string => value !== null),
+        ),
+      );
+    }
+
+    const singleValue = this.normalizeMediaTypeValue(rawMediaTypes);
+    return singleValue ? [singleValue] : ['image'];
+  }
+
+  private normalizeMediaTypeValue(rawValue?: string): string | null {
+    if (typeof rawValue !== 'string' || rawValue.length === 0) {
+      return 'image';
+    }
+
+    switch (rawValue) {
+      case 'All':
+      case 'all':
+      case 'images':
+      case 'image':
+      case 'livePhotos':
+        return 'image';
+      case 'Videos':
+      case 'videos':
+      case 'video':
+        return 'video';
+      default:
+        return rawValue.includes('video') ? 'video' : rawValue.includes('image') ? 'image' : null;
+    }
+  }
+
+  private normalizeSelectedUris(photoUris: Array<string> | undefined | null): string[] {
+    if (!Array.isArray(photoUris)) {
+      return [];
+    }
+
+    return photoUris.filter(
+      (value): value is string => typeof value === 'string' && value.length > 0,
+    );
+  }
+
+  private async requestAuthorizedUris(photoUris: string[]): Promise<string[]> {
+    const helper = photoAccessHelper.getPhotoAccessHelper(this.ctx.uiAbilityContext);
+
+    try {
+      const authorizedUris = await helper.requestPhotoUrisReadPermission(photoUris);
+      const normalizedAuthorizedUris = this.normalizeSelectedUris(authorizedUris);
+      return normalizedAuthorizedUris.length > 0 ? normalizedAuthorizedUris : photoUris;
+    } catch (_error) {
+      return photoUris;
+    }
+  }
+
+  private async createImagePickerAsset(
+    assetUri: string,
+    originalUri: string,
+    fallbackType: 'image' | 'video' | null,
+  ): Promise<ImagePickerAsset> {
+    const inferredType = this.inferAssetTypeFromUri(assetUri, fallbackType);
+    const imageSize =
+      inferredType === 'image' ? await this.getImageSize(assetUri) : { width: 0, height: 0 };
+    const fileSize = await this.getFileSize(assetUri);
+    const fileName = this.extractFileName(assetUri) ?? this.extractFileName(originalUri);
+
+    return {
+      uri: assetUri,
+      assetId: originalUri,
+      width: imageSize.width,
+      height: imageSize.height,
+      type: inferredType,
+      fileName,
+      fileSize,
+      mimeType: this.inferMimeType(assetUri, inferredType),
+      duration: inferredType === 'video' ? await this.getVideoDuration(assetUri) : null,
+      exif: null,
+      base64: null,
+    };
+  }
+
+  private inferAssetTypeFromUri(
+    assetUri: string,
+    fallbackType: 'image' | 'video' | null,
+  ): 'image' | 'video' | null {
+    const normalizedUri = assetUri.toLowerCase();
+
+    if (normalizedUri.match(/\\.(mp4|m4v|mov|3gp|webm)(\\?|#|$)/)) {
+      return 'video';
+    }
+
+    if (normalizedUri.match(/\\.(png|jpe?g|gif|bmp|webp|heic|heif)(\\?|#|$)/)) {
+      return 'image';
+    }
+
+    return fallbackType;
+  }
+
+  private inferMimeType(
+    assetUri: string,
+    assetType: 'image' | 'video' | null,
+  ): string | null {
+    const normalizedUri = assetUri.toLowerCase();
+
+    if (normalizedUri.endsWith('.png')) {
+      return 'image/png';
+    }
+    if (normalizedUri.endsWith('.gif')) {
+      return 'image/gif';
+    }
+    if (normalizedUri.endsWith('.webp')) {
+      return 'image/webp';
+    }
+    if (normalizedUri.endsWith('.bmp')) {
+      return 'image/bmp';
+    }
+    if (normalizedUri.endsWith('.heic')) {
+      return 'image/heic';
+    }
+    if (normalizedUri.endsWith('.heif')) {
+      return 'image/heif';
+    }
+    if (normalizedUri.match(/\\.jpe?g(\\?|#|$)/)) {
+      return 'image/jpeg';
+    }
+    if (normalizedUri.match(/\\.(mp4|m4v)(\\?|#|$)/)) {
+      return 'video/mp4';
+    }
+    if (normalizedUri.match(/\\.mov(\\?|#|$)/)) {
+      return 'video/quicktime';
+    }
+    if (normalizedUri.match(/\\.webm(\\?|#|$)/)) {
+      return 'video/webm';
+    }
+
+    return assetType === 'video' ? 'video/*' : assetType === 'image' ? 'image/*' : null;
+  }
+
+  private extractFileName(assetUri: string): string | null {
+    if (typeof assetUri !== 'string' || assetUri.length === 0) {
+      return null;
+    }
+
+    const sanitizedUri = assetUri.split('?')[0]?.split('#')[0] ?? assetUri;
+    const lastSlashIndex = sanitizedUri.lastIndexOf('/');
+    const rawFileName =
+      lastSlashIndex >= 0 ? sanitizedUri.slice(lastSlashIndex + 1) : sanitizedUri;
+
+    if (rawFileName.length === 0) {
+      return null;
+    }
+
+    try {
+      return decodeURIComponent(rawFileName);
+    } catch (_error) {
+      return rawFileName;
+    }
+  }
+
+  private async getImageSize(assetUri: string): Promise<{ width: number; height: number }> {
+    let imageSource: image.ImageSource | null = null;
+
+    try {
+      imageSource = image.createImageSource(assetUri);
+      const imageInfo = await imageSource.getImageInfo();
+      return {
+        width: Number(imageInfo.size?.width ?? 0),
+        height: Number(imageInfo.size?.height ?? 0),
+      };
+    } catch (_error) {
+      return {
+        width: 0,
+        height: 0,
+      };
+    } finally {
+      if (imageSource) {
+        try {
+          await imageSource.release();
+        } catch (_error) {
+          // Ignore cleanup errors from ImageSource release.
+        }
+      }
+    }
+  }
+
+  private async getFileSize(assetUri: string): Promise<number | null> {
+    const fsTarget = this.resolveFsTarget(assetUri);
+
+    if (!fsTarget) {
+      return null;
+    }
+
+    try {
+      const stat = await fs.stat(fsTarget);
+      return Number(stat.size ?? 0);
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  private async getVideoDuration(_assetUri: string): Promise<number | null> {
+    return 0;
+  }
+
+  private resolveFsTarget(assetUri: string): string | null {
+    if (assetUri.startsWith('file://')) {
+      return assetUri.slice('file://'.length);
+    }
+
+    return assetUri.startsWith('/') ? assetUri : null;
+  }
+
+  private createCanceledResult(): ImagePickerResult {
+    return {
+      canceled: true,
+      assets: null,
+    };
+  }
+}
+`;
+}
+function renderExpoHarmonyLocationTurboModule() {
+    return `import type { Permissions } from '@ohos.abilityAccessCtrl';
+import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
+import geoLocationManager from '@ohos.geoLocationManager';
+import { sensor } from '@kit.SensorServiceKit';
+import { AnyThreadTurboModuleContext, AnyThreadTurboModule } from '@rnoh/react-native-openharmony/ts';
+
+type PermissionResponse = {
+  status: 'granted' | 'denied' | 'undetermined';
+  granted: boolean;
+  canAskAgain: boolean;
+  expires: 'never';
+  android: {
+    accuracy: 'fine' | 'coarse' | 'none';
+  };
+};
+
+type ExpoLocationObject = {
+  coords: {
+    latitude: number;
+    longitude: number;
+    altitude: number | null;
+    accuracy: number | null;
+    altitudeAccuracy: number | null;
+    heading: number | null;
+    speed: number | null;
+  };
+  timestamp: number;
+  mocked: false;
+};
+
+type ProviderStatus = {
+  locationServicesEnabled: boolean;
+  backgroundModeEnabled: boolean;
+  gpsAvailable: boolean;
+  networkAvailable: boolean;
+  passiveAvailable: boolean;
+};
+
+type ReverseGeocodeResult = {
+  city: string | null;
+  district: string | null;
+  streetNumber: string | null;
+  street: string | null;
+  region: string | null;
+  subregion: string | null;
+  country: string | null;
+  postalCode: string | null;
+  name: string | null;
+  isoCountryCode: string | null;
+  timezone: null;
+  formattedAddress: string | null;
+};
+
+type GeocodeResult = {
+  latitude: number;
+  longitude: number;
+  altitude?: number;
+  accuracy?: number;
+};
+
+type HeadingObject = {
+  magHeading: number;
+  trueHeading: number | null;
+  accuracy: number;
+};
+
+export class ExpoHarmonyLocationTurboModule extends AnyThreadTurboModule {
+  public static readonly NAME = 'ExpoHarmonyLocation';
+
+  private readonly atManager = abilityAccessCtrl.createAtManager();
+  private nextWatchId = 1;
+
+  getConstants(): Record<string, never> {
+    return {};
+  }
+
+  async getForegroundPermissionStatus(): Promise<PermissionResponse> {
+    return this.getLocationPermissionResponse();
+  }
+
+  async requestForegroundPermission(): Promise<PermissionResponse> {
+    return this.requestLocationPermissionResponse();
+  }
+
+  async getBackgroundPermissionStatus(): Promise<PermissionResponse> {
+    const backgroundStatus = this.resolvePermissionStatus('ohos.permission.LOCATION_IN_BACKGROUND');
+    return this.buildBackgroundPermissionResponse(backgroundStatus);
+  }
+
+  async requestBackgroundPermission(): Promise<PermissionResponse> {
+    await this.atManager.requestPermissionsFromUser(this.ctx.uiAbilityContext, [
+      'ohos.permission.LOCATION_IN_BACKGROUND',
+    ]);
+    return this.getBackgroundPermissionStatus();
+  }
+
+  async hasServicesEnabled(): Promise<boolean> {
+    return geoLocationManager.isLocationEnabled();
+  }
+
+  async getProviderStatus(): Promise<ProviderStatus> {
+    const locationServicesEnabled = geoLocationManager.isLocationEnabled();
+
+    return {
+      locationServicesEnabled,
+      backgroundModeEnabled:
+        this.resolvePermissionStatus('ohos.permission.LOCATION_IN_BACKGROUND') ===
+        abilityAccessCtrl.PermissionStatus.GRANTED,
+      gpsAvailable: locationServicesEnabled,
+      networkAvailable: locationServicesEnabled,
+      passiveAvailable: locationServicesEnabled,
+    };
+  }
+
+  async getCurrentPosition(options?: { accuracy?: number }): Promise<ExpoLocationObject> {
+    const location = await geoLocationManager.getCurrentLocation(
+      this.createCurrentLocationRequest(options?.accuracy),
+    );
+    return this.normalizeLocation(location);
+  }
+
+  async getLastKnownPosition(_options?: Record<string, unknown>): Promise<ExpoLocationObject | null> {
+    try {
+      const location = geoLocationManager.getLastLocation();
+      return this.hasCoordinates(location) ? this.normalizeLocation(location) : null;
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  async geocode(address: string): Promise<GeocodeResult[]> {
+    const addresses = await geoLocationManager.getAddressesFromLocationName({
+      description: address,
+      locale: 'en-US',
+      maxItems: 5,
+    });
+
+    return addresses.map((addressEntry) => ({
+      latitude: Number(addressEntry.latitude ?? 0),
+      longitude: Number(addressEntry.longitude ?? 0),
+    }));
+  }
+
+  async reverseGeocode(location: { latitude: number; longitude: number }): Promise<ReverseGeocodeResult[]> {
+    const addresses = await geoLocationManager.getAddressesFromLocation({
+      latitude: Number(location.latitude),
+      longitude: Number(location.longitude),
+      locale: 'en-US',
+      maxItems: 5,
+    });
+
+    return addresses.map((addressEntry) => ({
+      city: addressEntry.locality ?? null,
+      district: addressEntry.subLocality ?? null,
+      streetNumber: addressEntry.subThoroughfare ?? null,
+      street: addressEntry.thoroughfare ?? null,
+      region: addressEntry.administrativeArea ?? null,
+      subregion: addressEntry.subAdministrativeArea ?? null,
+      country: addressEntry.countryName ?? null,
+      postalCode: addressEntry.postalCode ?? null,
+      name: addressEntry.placeName ?? null,
+      isoCountryCode: addressEntry.countryCode ?? null,
+      timezone: null,
+      formattedAddress:
+        addressEntry.addressUrl ??
+        (Array.isArray(addressEntry.descriptions) && addressEntry.descriptions.length > 0
+          ? addressEntry.descriptions.join(', ')
+          : null),
+    }));
+  }
+
+  async startWatchPosition(
+    options?: { accuracy?: number },
+    _listenerConfig?: Record<string, unknown>,
+  ): Promise<{ watchId: number; initialLocation: ExpoLocationObject | null }> {
+    const watchId = this.nextWatchId++;
+    return {
+      watchId,
+      initialLocation: await this.getLastKnownPosition(options ?? {}),
+    };
+  }
+
+  async stopWatchPosition(_watchId: number): Promise<void> {
+    return;
+  }
+
+  async getHeading(): Promise<HeadingObject> {
+    return this.readHeadingSnapshot();
+  }
+
+  async startWatchHeading(
+    _listenerConfig?: Record<string, unknown>,
+  ): Promise<{ watchId: number; initialHeading: HeadingObject }> {
+    const watchId = this.nextWatchId++;
+    return {
+      watchId,
+      initialHeading: await this.getHeading(),
+    };
+  }
+
+  async stopWatchHeading(_watchId: number): Promise<void> {
+    return;
+  }
+
+  private async getLocationPermissionResponse(): Promise<PermissionResponse> {
+    const approximateStatus = this.resolvePermissionStatus('ohos.permission.APPROXIMATELY_LOCATION');
+    const preciseStatus = this.resolvePermissionStatus('ohos.permission.LOCATION');
+
+    return this.buildPermissionResponse(approximateStatus, preciseStatus);
+  }
+
+  private buildBackgroundPermissionResponse(
+    backgroundStatus: abilityAccessCtrl.PermissionStatus,
+  ): PermissionResponse {
+    const foreground = this.getLocationPermissionResponse();
+    const granted = backgroundStatus === abilityAccessCtrl.PermissionStatus.GRANTED;
+    const denied =
+      backgroundStatus === abilityAccessCtrl.PermissionStatus.DENIED ||
+      backgroundStatus === abilityAccessCtrl.PermissionStatus.RESTRICTED ||
+      backgroundStatus === abilityAccessCtrl.PermissionStatus.INVALID;
+
+    return foreground.then((foregroundPermission) => ({
+      ...foregroundPermission,
+      status: granted ? 'granted' : denied ? 'denied' : 'undetermined',
+      granted,
+      canAskAgain: !denied,
+    }));
+  }
+
+  private async requestLocationPermissionResponse(): Promise<PermissionResponse> {
+    await this.atManager.requestPermissionsFromUser(this.ctx.uiAbilityContext, [
+      'ohos.permission.APPROXIMATELY_LOCATION',
+      'ohos.permission.LOCATION',
+    ]);
+
+    return this.getLocationPermissionResponse();
+  }
+
+  private resolvePermissionStatus(permissionName: Permissions): abilityAccessCtrl.PermissionStatus {
+    const atManagerWithSelfStatus = this.atManager as abilityAccessCtrl.AtManager & {
+      getSelfPermissionStatus?: (permission: Permissions) => abilityAccessCtrl.PermissionStatus;
+    };
+
+    if (typeof atManagerWithSelfStatus.getSelfPermissionStatus === 'function') {
+      return atManagerWithSelfStatus.getSelfPermissionStatus(permissionName);
+    }
+
+    const accessTokenId = this.ctx.uiAbilityContext.abilityInfo.applicationInfo.accessTokenId;
+    const grantStatus = this.atManager.checkAccessTokenSync(accessTokenId, permissionName);
+
+    return grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED
+      ? abilityAccessCtrl.PermissionStatus.GRANTED
+      : abilityAccessCtrl.PermissionStatus.NOT_DETERMINED;
+  }
+
+  private buildPermissionResponse(
+    approximateStatus: abilityAccessCtrl.PermissionStatus,
+    preciseStatus: abilityAccessCtrl.PermissionStatus,
+  ): PermissionResponse {
+    const coarseGranted = approximateStatus === abilityAccessCtrl.PermissionStatus.GRANTED;
+    const fineGranted = preciseStatus === abilityAccessCtrl.PermissionStatus.GRANTED;
+    const granted = coarseGranted || fineGranted;
+    const denied =
+      (approximateStatus === abilityAccessCtrl.PermissionStatus.DENIED ||
+        approximateStatus === abilityAccessCtrl.PermissionStatus.RESTRICTED ||
+        approximateStatus === abilityAccessCtrl.PermissionStatus.INVALID) &&
+      (preciseStatus === abilityAccessCtrl.PermissionStatus.DENIED ||
+        preciseStatus === abilityAccessCtrl.PermissionStatus.RESTRICTED ||
+        preciseStatus === abilityAccessCtrl.PermissionStatus.INVALID);
+
+    return {
+      status: granted ? 'granted' : denied ? 'denied' : 'undetermined',
+      granted,
+      canAskAgain: !denied,
+      expires: 'never',
+      android: {
+        accuracy: fineGranted ? 'fine' : coarseGranted ? 'coarse' : 'none',
+      },
+    };
+  }
+
+  private createCurrentLocationRequest(accuracy?: number): geoLocationManager.CurrentLocationRequest {
+    if (typeof accuracy === 'number' && accuracy >= 4) {
+      return {
+        priority: geoLocationManager.LocationRequestPriority.ACCURACY,
+      };
+    }
+
+    if (typeof accuracy === 'number' && accuracy <= 2) {
+      return {
+        priority: geoLocationManager.LocationRequestPriority.LOW_POWER,
+      };
+    }
+
+    return {
+      priority: geoLocationManager.LocationRequestPriority.FIRST_FIX,
+    };
+  }
+
+  private hasCoordinates(location: geoLocationManager.Location | null | undefined): location is geoLocationManager.Location {
+    return (
+      !!location &&
+      typeof location.latitude === 'number' &&
+      typeof location.longitude === 'number'
+    );
+  }
+
+  private normalizeLocation(location: geoLocationManager.Location): ExpoLocationObject {
+    return {
+      coords: {
+        latitude: Number(location.latitude),
+        longitude: Number(location.longitude),
+        altitude: typeof location.altitude === 'number' ? location.altitude : null,
+        accuracy: typeof location.accuracy === 'number' ? location.accuracy : null,
+        altitudeAccuracy: null,
+        heading: typeof location.direction === 'number' ? location.direction : null,
+        speed: typeof location.speed === 'number' ? location.speed : null,
+      },
+      timestamp: Number(location.timeStamp ?? Date.now()),
+      mocked: false,
+    };
+  }
+
+  private async readHeadingSnapshot(): Promise<HeadingObject> {
+    return new Promise((resolve) => {
+      try {
+        sensor.once(sensor.SensorId.ROTATION_VECTOR, (data: Record<string, number>) => {
+          const x = Number(data?.x ?? 0);
+          const y = Number(data?.y ?? 0);
+          const z = Number(data?.z ?? 0);
+          const w = Number(data?.w ?? 1);
+          const sinyCosp = 2 * (w * z + x * y);
+          const cosyCosp = 1 - 2 * (y * y + z * z);
+          const magHeading = (Math.atan2(sinyCosp, cosyCosp) * 180 / Math.PI + 360) % 360;
+          resolve({
+            magHeading,
+            trueHeading: magHeading,
+            accuracy: 3,
+          });
+        });
+      } catch (_error) {
+        resolve({
+          magHeading: 0,
+          trueHeading: null,
+          accuracy: 0,
+        });
+      }
+    });
+  }
+}
+`;
+}
+function renderExpoHarmonyCameraTurboModule() {
+    return `import type { Permissions } from '@ohos.abilityAccessCtrl';
+import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
+import camera from '@ohos.multimedia.camera';
+import cameraPicker from '@ohos.multimedia.cameraPicker';
+import image from '@ohos.multimedia.image';
+import { UITurboModuleContext, UITurboModule } from '@rnoh/react-native-openharmony/ts';
+
+type PermissionResponse = {
+  status: 'granted' | 'denied' | 'undetermined';
+  granted: boolean;
+  canAskAgain: boolean;
+  expires: 'never';
+};
+
+type CameraCaptureResult = {
+  uri: string;
+  width: number;
+  height: number;
+  base64?: string;
+  exif: null;
+};
+
+type CameraRecordingResult = {
+  uri: string;
+  duration: number;
+  fileSize: number | null;
+  mimeType: string;
+};
+
+export class ExpoHarmonyCameraTurboModule extends UITurboModule {
+  public static readonly NAME = 'ExpoHarmonyCamera';
+
+  private readonly atManager = abilityAccessCtrl.createAtManager();
+  private readonly previewStates = new Map<string, 'running' | 'paused'>();
+  private readonly activeRecordings = new Map<string, CameraRecordingResult>();
+
+  getConstants(): Record<string, never> {
+    return {};
+  }
+
+  async getCameraPermissionStatus(): Promise<PermissionResponse> {
+    return this.getPermissionResponse('ohos.permission.CAMERA');
+  }
+
+  async requestCameraPermission(): Promise<PermissionResponse> {
+    return this.requestPermissionResponse('ohos.permission.CAMERA');
+  }
+
+  async getMicrophonePermissionStatus(): Promise<PermissionResponse> {
+    return this.getPermissionResponse('ohos.permission.MICROPHONE');
+  }
+
+  async requestMicrophonePermission(): Promise<PermissionResponse> {
+    return this.requestPermissionResponse('ohos.permission.MICROPHONE');
+  }
+
+  async createPreview(options?: { viewId?: string }): Promise<{ viewId: string; state: 'running' }> {
+    const viewId = typeof options?.viewId === 'string' && options.viewId.length > 0
+      ? options.viewId
+      : 'expo-harmony-camera-preview';
+    this.previewStates.set(viewId, 'running');
+    return {
+      viewId,
+      state: 'running',
+    };
+  }
+
+  async disposePreview(options?: { viewId?: string }): Promise<void> {
+    if (typeof options?.viewId === 'string') {
+      this.previewStates.delete(options.viewId);
+      this.activeRecordings.delete(options.viewId);
+    }
+  }
+
+  async pausePreview(options?: { viewId?: string }): Promise<{ paused: boolean }> {
+    if (typeof options?.viewId === 'string') {
+      this.previewStates.set(options.viewId, 'paused');
+    }
+    return {
+      paused: true,
+    };
+  }
+
+  async resumePreview(options?: { viewId?: string }): Promise<{ paused: boolean }> {
+    if (typeof options?.viewId === 'string') {
+      this.previewStates.set(options.viewId, 'running');
+    }
+    return {
+      paused: false,
+    };
+  }
+
+  async takePicture(options?: { cameraType?: string; viewId?: string }): Promise<CameraCaptureResult> {
+    const profile = new cameraPicker.PickerProfile();
+    profile.cameraPosition =
+      options?.cameraType === 'front'
+        ? camera.CameraPosition.CAMERA_POSITION_FRONT
+        : camera.CameraPosition.CAMERA_POSITION_BACK;
+
+    const result = await cameraPicker.pick(
+      this.ctx.uiAbilityContext,
+      [cameraPicker.PickerMediaType.PHOTO],
+      profile,
+    );
+
+    if (!result || typeof result.resultUri !== 'string' || result.resultUri.length === 0) {
+      throw new Error('Camera capture was canceled.');
+    }
+
+    const imageSize = await this.getImageSize(result.resultUri);
+
+    return {
+      uri: result.resultUri,
+      width: imageSize.width,
+      height: imageSize.height,
+      exif: null,
+    };
+  }
+
+  async startRecording(options?: { viewId?: string; cameraType?: string }): Promise<CameraRecordingResult> {
+    await this.requestPermissionResponse('ohos.permission.MICROPHONE');
+    const profile = new cameraPicker.PickerProfile();
+    profile.cameraPosition =
+      options?.cameraType === 'front'
+        ? camera.CameraPosition.CAMERA_POSITION_FRONT
+        : camera.CameraPosition.CAMERA_POSITION_BACK;
+
+    const result = await cameraPicker.pick(
+      this.ctx.uiAbilityContext,
+      [cameraPicker.PickerMediaType.VIDEO],
+      profile,
+    );
+
+    if (!result || typeof result.resultUri !== 'string' || result.resultUri.length === 0) {
+      throw new Error('Camera recording was canceled.');
+    }
+
+    const recording = {
+      uri: result.resultUri,
+      duration: 0,
+      fileSize: null,
+      mimeType: 'video/mp4',
+    };
+
+    if (typeof options?.viewId === 'string') {
+      this.activeRecordings.set(options.viewId, recording);
+    }
+
+    return recording;
+  }
+
+  async stopRecording(options?: { viewId?: string }): Promise<CameraRecordingResult | null> {
+    if (typeof options?.viewId === 'string') {
+      const recording = this.activeRecordings.get(options.viewId) ?? null;
+      this.activeRecordings.delete(options.viewId);
+      return recording;
+    }
+
+    return null;
+  }
+
+  async toggleRecording(options?: { viewId?: string; cameraType?: string }): Promise<CameraRecordingResult | null> {
+    if (typeof options?.viewId === 'string' && this.activeRecordings.has(options.viewId)) {
+      return this.stopRecording(options);
+    }
+
+    return this.startRecording(options);
+  }
+
+  private async getPermissionResponse(permissionName: Permissions): Promise<PermissionResponse> {
+    const atManagerWithSelfStatus = this.atManager as abilityAccessCtrl.AtManager & {
+      getSelfPermissionStatus?: (permission: Permissions) => abilityAccessCtrl.PermissionStatus;
+    };
+    const permissionStatus =
+      typeof atManagerWithSelfStatus.getSelfPermissionStatus === 'function'
+        ? atManagerWithSelfStatus.getSelfPermissionStatus(permissionName)
+        : this.atManager.checkAccessTokenSync(
+            this.ctx.uiAbilityContext.abilityInfo.applicationInfo.accessTokenId,
+            permissionName,
+          ) === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED
+          ? abilityAccessCtrl.PermissionStatus.GRANTED
+          : abilityAccessCtrl.PermissionStatus.NOT_DETERMINED;
+
+    return this.createPermissionResponse(permissionStatus);
+  }
+
+  private async requestPermissionResponse(permissionName: Permissions): Promise<PermissionResponse> {
+    await this.atManager.requestPermissionsFromUser(this.ctx.uiAbilityContext, [permissionName]);
+    return this.getPermissionResponse(permissionName);
+  }
+
+  private createPermissionResponse(
+    permissionStatus: abilityAccessCtrl.PermissionStatus,
+  ): PermissionResponse {
+    const granted = permissionStatus === abilityAccessCtrl.PermissionStatus.GRANTED;
+    const denied =
+      permissionStatus === abilityAccessCtrl.PermissionStatus.DENIED ||
+      permissionStatus === abilityAccessCtrl.PermissionStatus.RESTRICTED ||
+      permissionStatus === abilityAccessCtrl.PermissionStatus.INVALID;
+
+    return {
+      status: granted ? 'granted' : denied ? 'denied' : 'undetermined',
+      granted,
+      canAskAgain: !denied,
+      expires: 'never',
+    };
+  }
+
+  private async getImageSize(assetUri: string): Promise<{ width: number; height: number }> {
+    let imageSource: image.ImageSource | null = null;
+
+    try {
+      imageSource = image.createImageSource(assetUri);
+      const imageInfo = await imageSource.getImageInfo();
+      return {
+        width: Number(imageInfo.size?.width ?? 0),
+        height: Number(imageInfo.size?.height ?? 0),
+      };
+    } catch (_error) {
+      return {
+        width: 0,
+        height: 0,
+      };
+    } finally {
+      if (imageSource) {
+        try {
+          await imageSource.release();
+        } catch (_error) {
+          // Ignore cleanup errors from ImageSource release.
+        }
+      }
+    }
+  }
+}
+`;
+}
+function renderExpoFileSystemHarmonyAdapterShim(capability) {
+    return `'use strict';
+
+const { TurboModuleRegistry } = require('react-native');
+const { CodedError } = require('expo-modules-core');
+
+const FILE_SCHEME = 'file://';
+const NATIVE_MODULE_NAME = 'ExpoHarmonyFileSystem';
+const NATIVE_MODULE = TurboModuleRegistry.get(NATIVE_MODULE_NAME);
+const NATIVE_CONSTANTS = NATIVE_MODULE?.getConstants ? NATIVE_MODULE.getConstants() : {};
+
+function createError(code, message) {
+  return new CodedError(code, message);
+}
+
+function requireNativeModule(operationName) {
+  if (NATIVE_MODULE) {
+    return NATIVE_MODULE;
+  }
+
+  throw createError(
+    'ERR_EXPO_HARMONY_NATIVE_MODULE_MISSING',
+    '${capability.packageName} expected the ' +
+      NATIVE_MODULE_NAME +
+      ' TurboModule to be registered, but it was missing while running ' +
+      operationName +
+      '.',
+  );
+}
+
+function createUnsupportedError(operationName) {
+  return createError(
+    'ERR_EXPO_HARMONY_UNSUPPORTED',
+    '${capability.packageName} currently supports UTF-8 sandbox file operations only. Unsupported operation: ' +
+      operationName +
+      '.',
+  );
+}
+
+function toFileUri(pathValue, ensureTrailingSlash) {
+  if (typeof pathValue !== 'string' || pathValue.length === 0) {
+    return null;
+  }
+
+  const normalizedPath = pathValue.startsWith(FILE_SCHEME)
+    ? pathValue.slice(FILE_SCHEME.length)
+    : pathValue;
+  const withScheme = FILE_SCHEME + normalizedPath;
+
+  if (!ensureTrailingSlash) {
+    return withScheme;
+  }
+
+  let normalizedSchemePath = withScheme;
+
+  while (normalizedSchemePath.endsWith('/')) {
+    normalizedSchemePath = normalizedSchemePath.slice(0, -1);
+  }
+
+  return normalizedSchemePath + '/';
+}
+
+function normalizeInputPath(inputPath) {
+  if (typeof inputPath !== 'string' || inputPath.length === 0) {
+    throw createError(
+      'ERR_EXPO_HARMONY_INVALID_URI',
+      '${capability.packageName} expected a non-empty file URI.',
+    );
+  }
+
+  const normalizedPath = inputPath.startsWith(FILE_SCHEME)
+    ? inputPath.slice(FILE_SCHEME.length)
+    : inputPath;
+
+  if (!normalizedPath.startsWith('/')) {
+    throw createError(
+      'ERR_EXPO_HARMONY_INVALID_URI',
+      '${capability.packageName} supports only absolute file:// URIs inside the app sandbox.',
+    );
+  }
+
+  if (
+    normalizedPath.includes('/../') ||
+    normalizedPath.endsWith('/..') ||
+    normalizedPath.includes('/./')
+  ) {
+    throw createError(
+      'ERR_EXPO_HARMONY_INVALID_URI',
+      '${capability.packageName} does not accept relative path segments.',
+    );
+  }
+
+  return normalizedPath;
+}
+
+function normalizeStringEncoding(rawEncoding) {
+  if (rawEncoding == null || rawEncoding === 'utf8') {
+    return 'utf8';
+  }
+
+  if (rawEncoding === 'base64') {
+    return 'base64';
+  }
+
+  throw createUnsupportedError('encoding=' + String(rawEncoding));
+}
+
+function normalizeFileDownloadResult(result, requestedUri) {
+  return {
+    uri: result?.uri ?? String(requestedUri),
+    status:
+      typeof result?.status === 'number' && Number.isFinite(result.status)
+        ? result.status
+        : 200,
+    headers: result?.headers && typeof result.headers === 'object' ? result.headers : {},
+    md5: typeof result?.md5 === 'string' ? result.md5 : undefined,
+  };
+}
+
+function normalizeFileInfoResult(requestedUri, nativeResult) {
+  if (!nativeResult || nativeResult.exists !== true) {
+    return {
+      exists: false,
+      isDirectory: false,
+      uri: String(requestedUri),
+    };
+  }
+
+  const normalizedResult = {
+    exists: true,
+    uri: toFileUri(nativeResult.path, false) ?? String(requestedUri),
+    size: Number(nativeResult.size ?? 0),
+    isDirectory: nativeResult.isDirectory === true,
+    modificationTime: Number(nativeResult.modificationTime ?? 0),
+  };
+
+  if (typeof nativeResult.md5 === 'string' && nativeResult.md5.length > 0) {
+    normalizedResult.md5 = nativeResult.md5;
+  }
+
+  return normalizedResult;
+}
+
+function normalizeNativeError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+
+  if (error && typeof error === 'object') {
+    const code =
+      typeof error.code === 'number' || typeof error.code === 'string'
+        ? String(error.code)
+        : null;
+    const message =
+      typeof error.message === 'string' && error.message.length > 0
+        ? error.message
+        : typeof error.name === 'string' && error.name.length > 0
+          ? error.name
+          : JSON.stringify(error);
+
+    return new Error(code ? '[native:' + code + '] ' + message : message);
+  }
+
+  return new Error(String(error));
+}
+
+module.exports = {
+  documentDirectory: toFileUri(NATIVE_CONSTANTS.documentDirectoryPath, true),
+  cacheDirectory: toFileUri(NATIVE_CONSTANTS.cacheDirectoryPath, true),
+  bundleDirectory: toFileUri(NATIVE_CONSTANTS.bundleDirectoryPath, true),
+  EncodingType: {
+    UTF8: 'utf8',
+    Base64: 'base64',
+  },
+  FileSystemSessionType: {
+    BACKGROUND: 0,
+    FOREGROUND: 1,
+  },
+  async getInfoAsync(fileUri, options) {
+    const normalizedPath = normalizeInputPath(fileUri);
+    try {
+      const result = await requireNativeModule('getInfoAsync').getInfo(normalizedPath, {
+        md5: options?.md5 === true,
+      });
+      return normalizeFileInfoResult(fileUri, result);
+    } catch (error) {
+      throw normalizeNativeError(error);
+    }
+  },
+  async readAsStringAsync(fileUri, options) {
+    const normalizedPath = normalizeInputPath(fileUri);
+    try {
+      return await requireNativeModule('readAsStringAsync').readAsString(normalizedPath, {
+        encoding: normalizeStringEncoding(options?.encoding),
+        position: options?.position,
+        length: options?.length,
+      });
+    } catch (error) {
+      throw normalizeNativeError(error);
+    }
+  },
+  async writeAsStringAsync(fileUri, contents, options) {
+    const normalizedPath = normalizeInputPath(fileUri);
+    try {
+      await requireNativeModule('writeAsStringAsync').writeAsString(
+        normalizedPath,
+        String(contents),
+        {
+          encoding: normalizeStringEncoding(options?.encoding),
+          append: options?.append === true,
+        },
+      );
+    } catch (error) {
+      throw normalizeNativeError(error);
+    }
+  },
+  async deleteAsync(fileUri, options) {
+    const normalizedPath = normalizeInputPath(fileUri);
+    try {
+      await requireNativeModule('deleteAsync').deletePath(normalizedPath, {
+        idempotent: options?.idempotent === true,
+      });
+    } catch (error) {
+      throw normalizeNativeError(error);
+    }
+  },
+  async makeDirectoryAsync(fileUri, options) {
+    const normalizedPath = normalizeInputPath(fileUri);
+    try {
+      await requireNativeModule('makeDirectoryAsync').makeDirectory(normalizedPath, {
+        intermediates: options?.intermediates === true,
+      });
+    } catch (error) {
+      throw normalizeNativeError(error);
+    }
+  },
+  async readDirectoryAsync(fileUri) {
+    const normalizedPath = normalizeInputPath(fileUri);
+    try {
+      return await requireNativeModule('readDirectoryAsync').readDirectory(normalizedPath);
+    } catch (error) {
+      throw normalizeNativeError(error);
+    }
+  },
+  async copyAsync(options) {
+    const fromPath = normalizeInputPath(options?.from);
+    const toPath = normalizeInputPath(options?.to);
+    try {
+      await requireNativeModule('copyAsync').copy(fromPath, toPath);
+    } catch (error) {
+      throw normalizeNativeError(error);
+    }
+  },
+  async moveAsync(options) {
+    const fromPath = normalizeInputPath(options?.from);
+    const toPath = normalizeInputPath(options?.to);
+    try {
+      await requireNativeModule('moveAsync').move(fromPath, toPath);
+    } catch (error) {
+      throw normalizeNativeError(error);
+    }
+  },
+  async downloadAsync(url, fileUri, options) {
+    const normalizedPath = normalizeInputPath(fileUri);
+    try {
+      return normalizeFileDownloadResult(
+        await requireNativeModule('downloadAsync').download(
+          String(url),
+          normalizedPath,
+          {
+            headers: options?.headers ?? {},
+            md5: options?.md5 === true,
+          },
+        ),
+        fileUri,
+      );
+    } catch (error) {
+      throw normalizeNativeError(error);
+    }
+  },
+};
+`;
+}
+function renderExpoFileSystemPreviewShim(capability) {
+    return `'use strict';
+
+const { CodedError } = require('expo-modules-core');
+
+const PREVIEW_MESSAGE =
+  '${capability.packageName} is routed through the Expo Harmony ${capability.supportTier} bridge. Bundling is supported, but runtime file-system behavior is not verified yet.';
+
+function createPreviewError(operationName) {
+  return new CodedError(
+    'ERR_EXPO_HARMONY_PREVIEW',
+    PREVIEW_MESSAGE + ' Attempted operation: ' + operationName + '.',
+  );
+}
+
+async function unavailable(operationName) {
+  throw createPreviewError(operationName);
+}
+
+module.exports = {
+  cacheDirectory: 'file:///expo-harmony/cache/',
+  documentDirectory: 'file:///expo-harmony/document/',
+  bundleDirectory: 'file:///expo-harmony/bundle/',
+  EncodingType: {
+    UTF8: 'utf8',
+    Base64: 'base64',
+  },
+  FileSystemSessionType: {
+    BACKGROUND: 0,
+    FOREGROUND: 1,
+  },
+  getInfoAsync(path) {
+    return unavailable('getInfoAsync(' + String(path) + ')');
+  },
+  readAsStringAsync(path) {
+    return unavailable('readAsStringAsync(' + String(path) + ')');
+  },
+  writeAsStringAsync(path) {
+    return unavailable('writeAsStringAsync(' + String(path) + ')');
+  },
+  deleteAsync(path) {
+    return unavailable('deleteAsync(' + String(path) + ')');
+  },
+  makeDirectoryAsync(path) {
+    return unavailable('makeDirectoryAsync(' + String(path) + ')');
+  },
+  readDirectoryAsync(path) {
+    return unavailable('readDirectoryAsync(' + String(path) + ')');
+  },
+  copyAsync(options) {
+    return unavailable('copyAsync(' + JSON.stringify(options ?? {}) + ')');
+  },
+  moveAsync(options) {
+    return unavailable('moveAsync(' + JSON.stringify(options ?? {}) + ')');
+  },
+  downloadAsync(url) {
+    return unavailable('downloadAsync(' + String(url) + ')');
+  },
+};
+`;
+}
+function renderExpoImagePickerHarmonyAdapterShim(capability) {
+    return `'use strict';
+
+const { TurboModuleRegistry } = require('react-native');
+const { CodedError } = require('expo-modules-core');
+
+const NATIVE_MODULE_NAME = 'ExpoHarmonyImagePicker';
+const NATIVE_MODULE = TurboModuleRegistry.get(NATIVE_MODULE_NAME);
+
+function createError(code, message) {
+  return new CodedError(code, message);
+}
+
+function requireNativeModule(operationName) {
+  if (NATIVE_MODULE) {
+    return NATIVE_MODULE;
+  }
+
+  throw createError(
+    'ERR_EXPO_HARMONY_NATIVE_MODULE_MISSING',
+    '${capability.packageName} expected the ' +
+      NATIVE_MODULE_NAME +
+      ' TurboModule to be registered, but it was missing while running ' +
+      operationName +
+      '.',
+  );
+}
+
+function normalizeNativeError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+
+  if (error && typeof error === 'object') {
+    const code =
+      typeof error.code === 'number' || typeof error.code === 'string'
+        ? String(error.code)
+        : null;
+    const message =
+      typeof error.message === 'string' && error.message.length > 0
+        ? error.message
+        : typeof error.name === 'string' && error.name.length > 0
+          ? error.name
+          : JSON.stringify(error);
+
+    return new Error(code ? '[native:' + code + '] ' + message : message);
+  }
+
+  return new Error(String(error));
+}
+
+function normalizePickerResult(result) {
+  if (!result || result.canceled === true || !Array.isArray(result.assets) || result.assets.length === 0) {
+    return {
+      canceled: true,
+      assets: null,
+    };
+  }
+
+  return {
+    canceled: false,
+    assets: result.assets.map((asset) => ({
+      uri: String(asset.uri),
+      assetId: asset.assetId ?? null,
+      width: Number(asset.width ?? 0),
+      height: Number(asset.height ?? 0),
+      type: asset.type ?? null,
+      fileName: asset.fileName ?? null,
+      fileSize:
+        typeof asset.fileSize === 'number' && Number.isFinite(asset.fileSize)
+          ? asset.fileSize
+          : null,
+      mimeType: asset.mimeType ?? null,
+      duration:
+        typeof asset.duration === 'number' && Number.isFinite(asset.duration)
+          ? asset.duration
+          : null,
+      exif: asset.exif ?? null,
+      base64: asset.base64 ?? null,
+    })),
+  };
+}
+
+async function invokeNative(methodName, operationName, ...args) {
+  try {
+    return await requireNativeModule(operationName)[methodName](...args);
+  } catch (error) {
+    throw normalizeNativeError(error);
+  }
+}
+
+module.exports = {
+  MediaTypeOptions: {
+    All: 'All',
+    Images: 'Images',
+    Videos: 'Videos',
+  },
+  CameraType: {
+    front: 'front',
+    back: 'back',
+  },
+  UIImagePickerPresentationStyle: {
+    AUTOMATIC: 'automatic',
+    FULL_SCREEN: 'fullScreen',
+    PAGE_SHEET: 'pageSheet',
+    FORM_SHEET: 'formSheet',
+    CURRENT_CONTEXT: 'currentContext',
+    OVER_FULL_SCREEN: 'overFullScreen',
+  },
+  async requestCameraPermissionsAsync() {
+    return invokeNative(
+      'requestCameraPermission',
+      'requestCameraPermissionsAsync',
+    );
+  },
+  async requestMediaLibraryPermissionsAsync(writeOnly) {
+    return invokeNative(
+      'requestMediaLibraryPermission',
+      'requestMediaLibraryPermissionsAsync',
+      writeOnly === true,
+    );
+  },
+  async getCameraPermissionsAsync() {
+    return invokeNative('getCameraPermissionStatus', 'getCameraPermissionsAsync');
+  },
+  async getMediaLibraryPermissionsAsync(writeOnly) {
+    return invokeNative(
+      'getMediaLibraryPermissionStatus',
+      'getMediaLibraryPermissionsAsync',
+      writeOnly === true,
+    );
+  },
+  async launchCameraAsync(options) {
+    return normalizePickerResult(
+      await invokeNative('launchCamera', 'launchCameraAsync', options ?? {}),
+    );
+  },
+  async launchImageLibraryAsync(options) {
+    return normalizePickerResult(
+      await invokeNative('launchImageLibrary', 'launchImageLibraryAsync', options ?? {}),
+    );
+  },
+  async getPendingResultAsync() {
+    const result = await invokeNative('getPendingResult', 'getPendingResultAsync');
+    return result ? normalizePickerResult(result) : null;
+  },
+};
+`;
+}
+function renderExpoLocationHarmonyAdapterShim(capability) {
+    return `'use strict';
+
+const { TurboModuleRegistry } = require('react-native');
+const { CodedError } = require('expo-modules-core');
+
+const NATIVE_MODULE_NAME = 'ExpoHarmonyLocation';
+const NATIVE_MODULE = TurboModuleRegistry.get(NATIVE_MODULE_NAME);
+
+function createError(code, message) {
+  return new CodedError(code, message);
+}
+
+function createUnsupportedError(operationName) {
+  return createError(
+    'ERR_EXPO_HARMONY_UNSUPPORTED',
+    '${capability.packageName} does not implement ' + operationName + ' on HarmonyOS yet.',
+  );
+}
+
+function requireNativeModule(operationName) {
+  if (NATIVE_MODULE) {
+    return NATIVE_MODULE;
+  }
+
+  throw createError(
+    'ERR_EXPO_HARMONY_NATIVE_MODULE_MISSING',
+    '${capability.packageName} expected the ' +
+      NATIVE_MODULE_NAME +
+      ' TurboModule to be registered, but it was missing while running ' +
+      operationName +
+      '.',
+  );
+}
+
+function normalizeNativeError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+
+  if (error && typeof error === 'object') {
+    const code =
+      typeof error.code === 'number' || typeof error.code === 'string'
+        ? String(error.code)
+        : null;
+    const message =
+      typeof error.message === 'string' && error.message.length > 0
+        ? error.message
+        : typeof error.name === 'string' && error.name.length > 0
+          ? error.name
+          : JSON.stringify(error);
+
+    return new Error(code ? '[native:' + code + '] ' + message : message);
+  }
+
+  return new Error(String(error));
+}
+
+async function invokeNative(methodName, operationName, ...args) {
+  try {
+    return await requireNativeModule(operationName)[methodName](...args);
+  } catch (error) {
+    throw normalizeNativeError(error);
+  }
+}
+
+function normalizePermissionResponse(permissionResponse) {
+  return {
+    status: permissionResponse?.status ?? 'undetermined',
+    granted: permissionResponse?.granted === true,
+    canAskAgain: permissionResponse?.canAskAgain !== false,
+    expires: permissionResponse?.expires ?? 'never',
+    android: permissionResponse?.android ?? { accuracy: 'none' },
+    ios: permissionResponse?.ios ?? null,
+  };
+}
+
+function normalizeLocationObject(location) {
+  return {
+    coords: {
+      latitude: Number(location?.coords?.latitude ?? 0),
+      longitude: Number(location?.coords?.longitude ?? 0),
+      altitude:
+        typeof location?.coords?.altitude === 'number' ? location.coords.altitude : null,
+      accuracy:
+        typeof location?.coords?.accuracy === 'number' ? location.coords.accuracy : null,
+      altitudeAccuracy:
+        typeof location?.coords?.altitudeAccuracy === 'number'
+          ? location.coords.altitudeAccuracy
+          : null,
+      heading: typeof location?.coords?.heading === 'number' ? location.coords.heading : null,
+      speed: typeof location?.coords?.speed === 'number' ? location.coords.speed : null,
+    },
+    timestamp: Number(location?.timestamp ?? Date.now()),
+    mocked: location?.mocked === true,
+  };
+}
+
+function normalizeProviderStatus(providerStatus) {
+  return {
+    locationServicesEnabled: providerStatus?.locationServicesEnabled === true,
+    backgroundModeEnabled: providerStatus?.backgroundModeEnabled === true,
+    gpsAvailable: providerStatus?.gpsAvailable === true,
+    networkAvailable: providerStatus?.networkAvailable === true,
+    passiveAvailable: providerStatus?.passiveAvailable === true,
+  };
+}
+
+function normalizeReverseGeocodeResult(address) {
+  return {
+    city: address?.city ?? null,
+    district: address?.district ?? null,
+    streetNumber: address?.streetNumber ?? null,
+    street: address?.street ?? null,
+    region: address?.region ?? null,
+    subregion: address?.subregion ?? null,
+    country: address?.country ?? null,
+    postalCode: address?.postalCode ?? null,
+    name: address?.name ?? null,
+    isoCountryCode: address?.isoCountryCode ?? null,
+    timezone: address?.timezone ?? null,
+    formattedAddress: address?.formattedAddress ?? null,
+  };
+}
+
+function normalizeGeocodeInput(address) {
+  if (typeof address === 'string') {
+    return address.trim();
+  }
+
+  if (!address || typeof address !== 'object') {
+    return '';
+  }
+
+  const parts = [
+    address.name,
+    address.streetNumber,
+    address.street,
+    address.district,
+    address.city,
+    address.region,
+    address.postalCode,
+    address.country,
+  ]
+    .filter((part) => typeof part === 'string' && part.trim().length > 0)
+    .map((part) => part.trim());
+
+  return parts.join(', ');
+}
+
+function normalizeGeocodeResults(results) {
+  if (!Array.isArray(results)) {
+    return [];
+  }
+
+  return results.map((result) => ({
+    latitude: Number(result?.latitude ?? 0),
+    longitude: Number(result?.longitude ?? 0),
+    altitude: typeof result?.altitude === 'number' ? result.altitude : null,
+    accuracy: typeof result?.accuracy === 'number' ? result.accuracy : null,
+  }));
+}
+
+function normalizeHeadingObject(heading) {
+  return {
+    magHeading: Number(heading?.magHeading ?? 0),
+    trueHeading:
+      typeof heading?.trueHeading === 'number' && Number.isFinite(heading.trueHeading)
+        ? heading.trueHeading
+        : null,
+    accuracy:
+      typeof heading?.accuracy === 'number' && Number.isFinite(heading.accuracy)
+        ? heading.accuracy
+        : 0,
+  };
+}
+
+function createSubscription(remove) {
+  let active = true;
+
+  return {
+    remove() {
+      if (!active) {
+        return;
+      }
+
+      active = false;
+      remove();
+    },
+  };
+}
+
+module.exports = {
+  Accuracy: {
+    Lowest: 1,
+    Low: 2,
+    Balanced: 3,
+    High: 4,
+    Highest: 5,
+    BestForNavigation: 6,
+  },
+  PermissionStatus: {
+    DENIED: 'denied',
+    GRANTED: 'granted',
+    UNDETERMINED: 'undetermined',
+  },
+  async getForegroundPermissionsAsync() {
+    return normalizePermissionResponse(
+      await invokeNative(
+        'getForegroundPermissionStatus',
+        'getForegroundPermissionsAsync',
+      ),
+    );
+  },
+  async requestForegroundPermissionsAsync() {
+    return normalizePermissionResponse(
+      await invokeNative(
+        'requestForegroundPermission',
+        'requestForegroundPermissionsAsync',
+      ),
+    );
+  },
+  async getBackgroundPermissionsAsync() {
+    return normalizePermissionResponse(
+      await invokeNative(
+        'getBackgroundPermissionStatus',
+        'getBackgroundPermissionsAsync',
+      ),
+    );
+  },
+  async requestBackgroundPermissionsAsync() {
+    return normalizePermissionResponse(
+      await invokeNative(
+        'requestBackgroundPermission',
+        'requestBackgroundPermissionsAsync',
+      ),
+    );
+  },
+  async hasServicesEnabledAsync() {
+    return await invokeNative('hasServicesEnabled', 'hasServicesEnabledAsync');
+  },
+  async getProviderStatusAsync() {
+    return normalizeProviderStatus(
+      await invokeNative('getProviderStatus', 'getProviderStatusAsync'),
+    );
+  },
+  async getCurrentPositionAsync(options) {
+    return normalizeLocationObject(
+      await invokeNative('getCurrentPosition', 'getCurrentPositionAsync', options ?? {}),
+    );
+  },
+  async getLastKnownPositionAsync(options) {
+    const location = await invokeNative(
+      'getLastKnownPosition',
+      'getLastKnownPositionAsync',
+      options ?? {},
+    );
+    return location ? normalizeLocationObject(location) : null;
+  },
+  async geocodeAsync(address) {
+    return normalizeGeocodeResults(
+      await invokeNative(
+        'geocode',
+        'geocodeAsync',
+        normalizeGeocodeInput(address),
+      ),
+    );
+  },
+  async reverseGeocodeAsync(location) {
+    const results = await invokeNative(
+      'reverseGeocode',
+      'reverseGeocodeAsync',
+      {
+        latitude: Number(location?.latitude ?? 0),
+        longitude: Number(location?.longitude ?? 0),
+      },
+    );
+
+    if (!Array.isArray(results)) {
+      return [];
+    }
+
+    return results.map(normalizeReverseGeocodeResult);
+  },
+  async watchPositionAsync(options, callback, errorHandler) {
+    if (typeof callback !== 'function') {
+      throw createError(
+        'ERR_EXPO_HARMONY_INVALID_LISTENER',
+        '${capability.packageName} expected watchPositionAsync to receive a callback.',
+      );
+    }
+
+    try {
+      const watchResult = await invokeNative(
+        'startWatchPosition',
+        'watchPositionAsync',
+        options ?? {},
+        null,
+      );
+      const watchId =
+        typeof watchResult?.watchId === 'number' ? watchResult.watchId : Number(Date.now());
+
+      if (watchResult?.initialLocation) {
+        callback(normalizeLocationObject(watchResult.initialLocation));
+      }
+
+      return createSubscription(() => {
+        void invokeNative(
+          'stopWatchPosition',
+          'Location.watchPositionAsync.remove',
+          watchId,
+        ).catch(() => {});
+      });
+    } catch (error) {
+      if (typeof errorHandler === 'function') {
+        errorHandler(error);
+      }
+
+      throw error;
+    }
+  },
+  async watchHeadingAsync(callback) {
+    if (typeof callback !== 'function') {
+      throw createError(
+        'ERR_EXPO_HARMONY_INVALID_LISTENER',
+        '${capability.packageName} expected watchHeadingAsync to receive a callback.',
+      );
+    }
+
+    const watchResult = await invokeNative(
+      'startWatchHeading',
+      'watchHeadingAsync',
+      null,
+    );
+    const watchId =
+      typeof watchResult?.watchId === 'number' ? watchResult.watchId : Number(Date.now());
+
+    if (watchResult?.initialHeading) {
+      callback(normalizeHeadingObject(watchResult.initialHeading));
+    }
+
+    return createSubscription(() => {
+      void invokeNative(
+        'stopWatchHeading',
+        'Location.watchHeadingAsync.remove',
+        watchId,
+      ).catch(() => {});
+    });
+  },
+  async getHeadingAsync() {
+    return normalizeHeadingObject(
+      await invokeNative('getHeading', 'getHeadingAsync'),
+    );
+  },
+};
+`;
+}
+function renderExpoImagePickerPreviewShim(capability) {
+    return `'use strict';
+
+const { CodedError } = require('expo-modules-core');
+
+const PREVIEW_MESSAGE =
+  '${capability.packageName} is routed through the Expo Harmony ${capability.supportTier} bridge. Bundling is supported, but picker and camera flows still need device-side validation.';
+
+function createPreviewError(operationName) {
+  return new CodedError(
+    'ERR_EXPO_HARMONY_PREVIEW',
+    PREVIEW_MESSAGE + ' Attempted operation: ' + operationName + '.',
+  );
+}
+
+async function unavailable(operationName) {
+  throw createPreviewError(operationName);
+}
+
+module.exports = {
+  MediaTypeOptions: {
+    All: 'All',
+    Images: 'Images',
+    Videos: 'Videos',
+  },
+  UIImagePickerPresentationStyle: {
+    AUTOMATIC: 'automatic',
+    FULL_SCREEN: 'fullScreen',
+    PAGE_SHEET: 'pageSheet',
+    FORM_SHEET: 'formSheet',
+    CURRENT_CONTEXT: 'currentContext',
+    OVER_FULL_SCREEN: 'overFullScreen',
+  },
+  requestCameraPermissionsAsync() {
+    return unavailable('requestCameraPermissionsAsync');
+  },
+  requestMediaLibraryPermissionsAsync() {
+    return unavailable('requestMediaLibraryPermissionsAsync');
+  },
+  getCameraPermissionsAsync() {
+    return unavailable('getCameraPermissionsAsync');
+  },
+  getMediaLibraryPermissionsAsync() {
+    return unavailable('getMediaLibraryPermissionsAsync');
+  },
+  launchCameraAsync(options) {
+    return unavailable('launchCameraAsync(' + JSON.stringify(options ?? {}) + ')');
+  },
+  launchImageLibraryAsync(options) {
+    return unavailable('launchImageLibraryAsync(' + JSON.stringify(options ?? {}) + ')');
+  },
+};
+`;
+}
+function renderExpoLocationPreviewShim(capability) {
+    return `'use strict';
+
+const { CodedError } = require('expo-modules-core');
+
+const PREVIEW_MESSAGE =
+  '${capability.packageName} is routed through the Expo Harmony ${capability.supportTier} bridge. Bundling is supported, but foreground permission, current-position, and watch flows still need device-side validation.';
+const DEFAULT_PERMISSION_RESPONSE = {
+  status: 'undetermined',
+  granted: false,
+  canAskAgain: true,
+  expires: 'never',
+};
+
+function createPreviewError(operationName) {
+  return new CodedError(
+    'ERR_EXPO_HARMONY_PREVIEW',
+    PREVIEW_MESSAGE + ' Attempted operation: ' + operationName + '.',
+  );
+}
+
+async function unavailable(operationName) {
+  throw createPreviewError(operationName);
+}
+
+function getPermissionResponse() {
+  return { ...DEFAULT_PERMISSION_RESPONSE };
+}
+
+module.exports = {
+  Accuracy: {
+    Lowest: 1,
+    Low: 2,
+    Balanced: 3,
+    High: 4,
+    Highest: 5,
+    BestForNavigation: 6,
+  },
+  PermissionStatus: {
+    DENIED: 'denied',
+    GRANTED: 'granted',
+    UNDETERMINED: 'undetermined',
+  },
+  requestForegroundPermissionsAsync() {
+    return unavailable('requestForegroundPermissionsAsync');
+  },
+  getForegroundPermissionsAsync() {
+    return Promise.resolve(getPermissionResponse());
+  },
+  requestBackgroundPermissionsAsync() {
+    return unavailable('requestBackgroundPermissionsAsync');
+  },
+  getBackgroundPermissionsAsync() {
+    return Promise.resolve(getPermissionResponse());
+  },
+  hasServicesEnabledAsync() {
+    return Promise.resolve(false);
+  },
+  getCurrentPositionAsync(options) {
+    return unavailable('getCurrentPositionAsync(' + JSON.stringify(options ?? {}) + ')');
+  },
+  getLastKnownPositionAsync(options) {
+    return unavailable('getLastKnownPositionAsync(' + JSON.stringify(options ?? {}) + ')');
+  },
+  watchPositionAsync(options) {
+    return unavailable('watchPositionAsync(' + JSON.stringify(options ?? {}) + ')');
+  },
+  geocodeAsync(address) {
+    return unavailable('geocodeAsync(' + JSON.stringify(address ?? null) + ')');
+  },
+  reverseGeocodeAsync(location) {
+    return unavailable('reverseGeocodeAsync(' + JSON.stringify(location ?? null) + ')');
+  },
+};
+`;
+}
+function renderExpoCameraHarmonyAdapterShim(capability) {
+    return `'use strict';
+
+const React = require('react');
+const { TurboModuleRegistry, requireNativeComponent } = require('react-native');
+const { CodedError } = require('expo-modules-core');
+
+const NATIVE_MODULE_NAME = 'ExpoHarmonyCamera';
+const NATIVE_MODULE = TurboModuleRegistry.get(NATIVE_MODULE_NAME);
+const NativeCameraView = requireNativeComponent('ExpoHarmonyCameraView');
+const DEFAULT_PERMISSION_RESPONSE = {
+  status: 'undetermined',
+  granted: false,
+  canAskAgain: true,
+  expires: 'never',
+};
+let nextCameraViewId = 1;
+
+function createError(code, message) {
+  return new CodedError(code, message);
+}
+
+function createUnsupportedError(operationName) {
+  return createError(
+    'ERR_EXPO_HARMONY_UNSUPPORTED',
+    '${capability.packageName} does not implement ' + operationName + ' on HarmonyOS yet.',
+  );
+}
+
+function requireNativeModule(operationName) {
+  if (NATIVE_MODULE) {
+    return NATIVE_MODULE;
+  }
+
+  throw createError(
+    'ERR_EXPO_HARMONY_NATIVE_MODULE_MISSING',
+    '${capability.packageName} expected the ' +
+      NATIVE_MODULE_NAME +
+      ' TurboModule to be registered, but it was missing while running ' +
+      operationName +
+      '.',
+  );
+}
+
+function normalizeNativeError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+
+  if (error && typeof error === 'object') {
+    const code =
+      typeof error.code === 'number' || typeof error.code === 'string'
+        ? String(error.code)
+        : null;
+    const message =
+      typeof error.message === 'string' && error.message.length > 0
+        ? error.message
+        : typeof error.name === 'string' && error.name.length > 0
+          ? error.name
+          : JSON.stringify(error);
+
+    return new Error(code ? '[native:' + code + '] ' + message : message);
+  }
+
+  return new Error(String(error));
+}
+
+async function invokeNative(methodName, operationName, ...args) {
+  try {
+    return await requireNativeModule(operationName)[methodName](...args);
+  } catch (error) {
+    throw normalizeNativeError(error);
+  }
+}
+
+function normalizePermissionResponse(permissionResponse) {
+  return {
+    status: permissionResponse?.status ?? DEFAULT_PERMISSION_RESPONSE.status,
+    granted: permissionResponse?.granted === true,
+    canAskAgain: permissionResponse?.canAskAgain !== false,
+    expires: permissionResponse?.expires ?? DEFAULT_PERMISSION_RESPONSE.expires,
+  };
+}
+
+function normalizeCameraFacing(facing) {
+  return facing === 'front' ? 'front' : 'back';
+}
+
+const CameraView = React.forwardRef(function ExpoHarmonyCameraView(props, ref) {
+  const viewIdRef = React.useRef(null);
+
+  if (!viewIdRef.current) {
+    viewIdRef.current = 'expo-harmony-camera-view-' + String(nextCameraViewId++);
+  }
+
+  const viewId = viewIdRef.current;
+
+  React.useEffect(() => {
+    void invokeNative('createPreview', 'CameraView.mount', {
+      viewId,
+      facing: normalizeCameraFacing(props.facing),
+      mode: props.mode ?? 'picture',
+    }).catch(() => {});
+
+    return () => {
+      void invokeNative('disposePreview', 'CameraView.unmount', {
+        viewId,
+      }).catch(() => {});
+    };
+  }, [props.facing, props.mode, viewId]);
+
+  React.useImperativeHandle(
+    ref,
+    () => ({
+      async takePictureAsync(options) {
+        return invokeNative('takePicture', 'CameraView.takePictureAsync', {
+          viewId,
+          cameraType: normalizeCameraFacing(props.facing),
+          ...options,
+        });
+      },
+      async pausePreview() {
+        return invokeNative('pausePreview', 'CameraView.pausePreview', {
+          viewId,
+        });
+      },
+      async resumePreview() {
+        return invokeNative('resumePreview', 'CameraView.resumePreview', {
+          viewId,
+        });
+      },
+      async getAvailablePictureSizesAsync() {
+        throw createUnsupportedError('CameraView.getAvailablePictureSizesAsync');
+      },
+      async getAvailableLensesAsync() {
+        throw createUnsupportedError('CameraView.getAvailableLensesAsync');
+      },
+      async recordAsync(options) {
+        return invokeNative('startRecording', 'CameraView.recordAsync', {
+          viewId,
+          cameraType: normalizeCameraFacing(props.facing),
+          ...options,
+        });
+      },
+      async stopRecording() {
+        return invokeNative('stopRecording', 'CameraView.stopRecording', {
+          viewId,
+        });
+      },
+      async toggleRecordingAsync(options) {
+        return invokeNative('toggleRecording', 'CameraView.toggleRecordingAsync', {
+          viewId,
+          cameraType: normalizeCameraFacing(props.facing),
+          ...options,
+        });
+      },
+    }),
+    [props.facing, viewId],
+  );
+
+  return React.createElement(NativeCameraView, {
+    ...props,
+    viewId,
+    facing: normalizeCameraFacing(props.facing),
+    accessibilityLabel: props.accessibilityLabel ?? 'Expo Harmony embedded camera preview',
+    style: [
+      {
+        minHeight: 220,
+        overflow: 'hidden',
+        backgroundColor: '#111827',
+      },
+      props.style,
+    ],
+  });
+});
+
+CameraView.displayName = 'ExpoHarmonyCameraView';
+
+async function getCameraPermissionsAsync() {
+  return normalizePermissionResponse(
+    await invokeNative('getCameraPermissionStatus', 'getCameraPermissionsAsync'),
+  );
+}
+
+async function requestCameraPermissionsAsync() {
+  return normalizePermissionResponse(
+    await invokeNative('requestCameraPermission', 'requestCameraPermissionsAsync'),
+  );
+}
+
+async function getMicrophonePermissionsAsync() {
+  return normalizePermissionResponse(
+    await invokeNative('getMicrophonePermissionStatus', 'getMicrophonePermissionsAsync'),
+  );
+}
+
+async function requestMicrophonePermissionsAsync() {
+  return normalizePermissionResponse(
+    await invokeNative('requestMicrophonePermission', 'requestMicrophonePermissionsAsync'),
+  );
+}
+
+module.exports = {
+  CameraType: {
+    front: 'front',
+    back: 'back',
+  },
+  FlashMode: {
+    off: 'off',
+    on: 'on',
+    auto: 'auto',
+    torch: 'torch',
+  },
+  CameraView,
+  Camera: {
+    CameraType: {
+      front: 'front',
+      back: 'back',
+    },
+    Constants: {
+      Type: {
+        front: 'front',
+        back: 'back',
+      },
+      FlashMode: {
+        off: 'off',
+        on: 'on',
+        auto: 'auto',
+        torch: 'torch',
+      },
+    },
+    getCameraPermissionsAsync,
+    requestCameraPermissionsAsync,
+    getMicrophonePermissionsAsync,
+    requestMicrophonePermissionsAsync,
+  },
+  getCameraPermissionsAsync,
+  requestCameraPermissionsAsync,
+  getMicrophonePermissionsAsync,
+  requestMicrophonePermissionsAsync,
+  async scanFromURLAsync() {
+    throw createUnsupportedError('scanFromURLAsync');
+  },
+};
+`;
+}
+function renderExpoCameraPreviewShim(capability) {
+    return `'use strict';
+
+const React = require('react');
+const { Text, View } = require('react-native');
+const { CodedError } = require('expo-modules-core');
+
+const PREVIEW_MESSAGE =
   '${capability.packageName} is routed through the Expo Harmony ${capability.supportTier} bridge. Bundling is supported, and a managed preview surface can render, but device-side camera permission and capture flows still need validation.';
 const DEFAULT_PERMISSION_RESPONSE = {
   status: 'undetermined',
@@ -1184,6 +4161,12 @@ const CameraView = React.forwardRef(function ExpoHarmonyCameraPreview(props, ref
     takePictureAsync(options) {
       return unavailable('CameraView.takePictureAsync(' + JSON.stringify(options ?? {}) + ')');
     },
+    pausePreview() {
+      return unavailable('CameraView.pausePreview()');
+    },
+    resumePreview() {
+      return unavailable('CameraView.resumePreview()');
+    },
   }));
 
   return React.createElement(
@@ -1246,6 +4229,23 @@ module.exports = {
   getMicrophonePermissionsAsync() {
     return Promise.resolve(getPermissionResponse());
   },
+  Camera: {
+    getCameraPermissionsAsync() {
+      return Promise.resolve(getPermissionResponse());
+    },
+    requestCameraPermissionsAsync() {
+      return unavailable('Camera.requestCameraPermissionsAsync');
+    },
+    getMicrophonePermissionsAsync() {
+      return Promise.resolve(getPermissionResponse());
+    },
+    requestMicrophonePermissionsAsync() {
+      return unavailable('Camera.requestMicrophonePermissionsAsync');
+    },
+  },
+  scanFromURLAsync() {
+    return unavailable('scanFromURLAsync');
+  },
 };
 `;
 }