@parrotnavy/rn-native-updates 0.1.0

package/src/api.ts

@@ -0,0 +1,239 @@
+import { Linking, Platform } from 'react-native';
+
+import { NativeUpdatesModule } from './NativeUpdatesModule';
+import {
+  type AppStoreInfo,
+  AppUpdateError,
+  AppUpdateErrorCode,
+  type GetLatestVersionOptions,
+  type GetStoreUrlOptions,
+  type NeedUpdateOptions,
+  type NeedUpdateResult,
+  type PlayStoreUpdateInfo,
+  UpdateAvailability,
+  type UpdateListener,
+  type UpdateSubscription,
+  type UpdateType,
+} from './types';
+import { isNewerVersion } from './versionUtils';
+
+export function getPackageName(): string {
+  return NativeUpdatesModule.packageName;
+}
+
+export function getCurrentVersion(): string {
+  return NativeUpdatesModule.currentVersion;
+}
+
+export function getCurrentBuildNumber(): number {
+  return Number.parseInt(NativeUpdatesModule.buildNumber, 10) || 0;
+}
+
+export function getCountry(): string {
+  return NativeUpdatesModule.country;
+}
+
+export async function getLatestVersion(options?: GetLatestVersionOptions): Promise<string> {
+  if (Platform.OS === 'ios') {
+    const info = await NativeUpdatesModule.getAppStoreVersion(
+      options?.country ?? null,
+      options?.forceRefresh ?? false,
+    );
+    return info.version;
+  }
+
+  if (Platform.OS === 'android') {
+    const info = await checkPlayStoreUpdate();
+    if (
+      info.updateAvailability === UpdateAvailability.UPDATE_AVAILABLE &&
+      info.availableVersionCode
+    ) {
+      return info.availableVersionCode.toString();
+    }
+    return getCurrentVersion();
+  }
+
+  throw new AppUpdateError(AppUpdateErrorCode.UNKNOWN, `Platform ${Platform.OS} is not supported`);
+}
+
+export async function getStoreUrl(options?: GetStoreUrlOptions): Promise<string> {
+  const packageName = getPackageName();
+
+  if (Platform.OS === 'ios') {
+    try {
+      const info = await NativeUpdatesModule.getAppStoreVersion(options?.country ?? null, false);
+      return info.trackViewUrl;
+    } catch {
+      const country = options?.country ?? getCountry();
+      return `https://apps.apple.com/${country.toLowerCase()}/app/id`;
+    }
+  }
+
+  if (Platform.OS === 'android') {
+    return `https://play.google.com/store/apps/details?id=${packageName}`;
+  }
+
+  throw new AppUpdateError(AppUpdateErrorCode.UNKNOWN, `Platform ${Platform.OS} is not supported`);
+}
+
+export async function needUpdate(options?: NeedUpdateOptions): Promise<NeedUpdateResult> {
+  const currentVersion = options?.currentVersion ?? getCurrentVersion();
+  const depth = options?.depth ?? Number.POSITIVE_INFINITY;
+
+  let latestVersion: string;
+  let storeUrl: string;
+
+  if (options?.latestVersion) {
+    latestVersion = options.latestVersion;
+    storeUrl = await getStoreUrl({ country: options?.country });
+  } else {
+    if (Platform.OS === 'ios') {
+      const info = await NativeUpdatesModule.getAppStoreVersion(
+        options?.country ?? null,
+        options?.forceRefresh ?? false,
+      );
+      latestVersion = info.version;
+      storeUrl = info.trackViewUrl;
+    } else if (Platform.OS === 'android') {
+      const info = await checkPlayStoreUpdate();
+      latestVersion = info.availableVersionCode?.toString() ?? currentVersion;
+      storeUrl = `https://play.google.com/store/apps/details?id=${getPackageName()}`;
+    } else {
+      throw new AppUpdateError(
+        AppUpdateErrorCode.UNKNOWN,
+        `Platform ${Platform.OS} is not supported`,
+      );
+    }
+  }
+
+  const isNeeded = isNewerVersion(currentVersion, latestVersion, depth);
+
+  return {
+    isNeeded,
+    currentVersion,
+    latestVersion,
+    storeUrl,
+  };
+}
+
+export async function openStore(options?: GetStoreUrlOptions): Promise<void> {
+  const url = await getStoreUrl(options);
+  const canOpen = await Linking.canOpenURL(url);
+
+  if (canOpen) {
+    await Linking.openURL(url);
+  } else {
+    throw new AppUpdateError(AppUpdateErrorCode.UNKNOWN, `Cannot open store URL: ${url}`);
+  }
+}
+
+export async function getAppStoreInfo(options?: GetLatestVersionOptions): Promise<AppStoreInfo> {
+  if (Platform.OS !== 'ios') {
+    throw new AppUpdateError(
+      AppUpdateErrorCode.UNKNOWN,
+      'getAppStoreInfo is only available on iOS',
+    );
+  }
+
+  return NativeUpdatesModule.getAppStoreVersion(
+    options?.country ?? null,
+    options?.forceRefresh ?? false,
+  );
+}
+
+export async function checkPlayStoreUpdate(): Promise<PlayStoreUpdateInfo> {
+  if (Platform.OS !== 'android') {
+    throw new AppUpdateError(
+      AppUpdateErrorCode.UNKNOWN,
+      'checkPlayStoreUpdate is only available on Android',
+    );
+  }
+
+  return NativeUpdatesModule.checkPlayStoreUpdate();
+}
+
+export async function startInAppUpdate(type: UpdateType): Promise<void> {
+  if (Platform.OS !== 'android') {
+    throw new AppUpdateError(
+      AppUpdateErrorCode.UNKNOWN,
+      'startInAppUpdate is only available on Android',
+    );
+  }
+
+  return NativeUpdatesModule.startUpdate(type);
+}
+
+export function completeInAppUpdate(): void {
+  if (Platform.OS !== 'android') {
+    throw new AppUpdateError(
+      AppUpdateErrorCode.UNKNOWN,
+      'completeInAppUpdate is only available on Android',
+    );
+  }
+
+  NativeUpdatesModule.completeUpdate();
+}
+
+let eventSubscription: { remove: () => void } | null = null;
+const listeners = new Set<UpdateListener>();
+
+function setupEventListener(): void {
+  if (eventSubscription || Platform.OS !== 'android') return;
+
+  const { EventEmitter } = require('expo-modules-core');
+  const emitter = new EventEmitter(NativeUpdatesModule);
+
+  const handleEvent = (_eventName: string, data: Record<string, unknown>) => {
+    const state = {
+      installStatus: (data.installStatus as number) ?? 0,
+      bytesDownloaded: (data.bytesDownloaded as number) ?? 0,
+      totalBytesToDownload: (data.totalBytesToDownload as number) ?? 0,
+      downloadProgress: (data.downloadProgress as number) ?? 0,
+    };
+
+    for (const listener of listeners) {
+      listener(state);
+    }
+  };
+
+  const progressSub = emitter.addListener('onUpdateProgress', (data: Record<string, unknown>) =>
+    handleEvent('onUpdateProgress', data),
+  );
+  const downloadedSub = emitter.addListener('onUpdateDownloaded', (data: Record<string, unknown>) =>
+    handleEvent('onUpdateDownloaded', data),
+  );
+  const installedSub = emitter.addListener('onUpdateInstalled', (data: Record<string, unknown>) =>
+    handleEvent('onUpdateInstalled', data),
+  );
+  const failedSub = emitter.addListener('onUpdateFailed', (data: Record<string, unknown>) =>
+    handleEvent('onUpdateFailed', data),
+  );
+
+  eventSubscription = {
+    remove: () => {
+      progressSub.remove();
+      downloadedSub.remove();
+      installedSub.remove();
+      failedSub.remove();
+      eventSubscription = null;
+    },
+  };
+}
+
+export function addUpdateListener(listener: UpdateListener): UpdateSubscription {
+  if (Platform.OS !== 'android') {
+    return { remove: () => {} };
+  }
+
+  setupEventListener();
+  listeners.add(listener);
+
+  return {
+    remove: () => {
+      listeners.delete(listener);
+      if (listeners.size === 0 && eventSubscription) {
+        eventSubscription.remove();
+      }
+    },
+  };
+}

package/src/hooks/index.ts

@@ -0,0 +1 @@
+export { useAppUpdate } from './useAppUpdate';

package/src/hooks/useAppUpdate.ts

@@ -0,0 +1,189 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Platform } from 'react-native';
+
+import {
+  addUpdateListener,
+  checkPlayStoreUpdate,
+  completeInAppUpdate,
+  getCurrentVersion,
+  needUpdate,
+  openStore,
+  startInAppUpdate,
+} from '../api';
+import {
+  AppUpdateError,
+  AppUpdateErrorCode,
+  InstallStatus,
+  type PlayStoreUpdateInfo,
+  UpdateAvailability,
+  type UpdateSubscription,
+  type UpdateType,
+  type UseAppUpdateOptions,
+  type UseAppUpdateResult,
+} from '../types';
+
+export function useAppUpdate(options?: UseAppUpdateOptions): UseAppUpdateResult {
+  const [isChecking, setIsChecking] = useState(false);
+  const [isUpdateAvailable, setIsUpdateAvailable] = useState(false);
+  const [currentVersion] = useState(getCurrentVersion);
+  const [latestVersion, setLatestVersion] = useState<string | null>(null);
+  const [storeUrl, setStoreUrl] = useState<string | null>(null);
+  const [error, setError] = useState<AppUpdateError | null>(null);
+
+  const [isDownloading, setIsDownloading] = useState(false);
+  const [downloadProgress, setDownloadProgress] = useState(0);
+  const [isReadyToInstall, setIsReadyToInstall] = useState(false);
+  const [playStoreInfo, setPlayStoreInfo] = useState<PlayStoreUpdateInfo | null>(null);
+
+  const subscriptionRef = useRef<UpdateSubscription | null>(null);
+  const mountedRef = useRef(true);
+
+  const checkUpdate = useCallback(async () => {
+    if (!mountedRef.current) return;
+
+    setIsChecking(true);
+    setError(null);
+
+    try {
+      const result = await needUpdate({
+        country: options?.country,
+        forceRefresh: true,
+      });
+
+      if (!mountedRef.current) return;
+
+      setIsUpdateAvailable(result.isNeeded);
+      setLatestVersion(result.latestVersion);
+      setStoreUrl(result.storeUrl);
+
+      if (Platform.OS === 'android') {
+        try {
+          const info = await checkPlayStoreUpdate();
+          if (mountedRef.current) {
+            setPlayStoreInfo(info);
+            setIsUpdateAvailable(info.updateAvailability === UpdateAvailability.UPDATE_AVAILABLE);
+          }
+        } catch {
+          if (mountedRef.current) {
+            setPlayStoreInfo(null);
+          }
+        }
+      }
+    } catch (e) {
+      if (!mountedRef.current) return;
+
+      const appError =
+        e instanceof AppUpdateError
+          ? e
+          : new AppUpdateError(AppUpdateErrorCode.CHECK_FAILED, String(e));
+
+      setError(appError);
+      options?.onError?.(appError);
+    } finally {
+      if (mountedRef.current) {
+        setIsChecking(false);
+      }
+    }
+  }, [options?.country, options?.onError]);
+
+  const handleOpenStore = useCallback(async () => {
+    try {
+      await openStore({ country: options?.country });
+    } catch (e) {
+      const appError =
+        e instanceof AppUpdateError ? e : new AppUpdateError(AppUpdateErrorCode.UNKNOWN, String(e));
+      setError(appError);
+      options?.onError?.(appError);
+    }
+  }, [options?.country, options?.onError]);
+
+  const handleStartUpdate = useCallback(
+    async (type: UpdateType) => {
+      if (Platform.OS !== 'android') return;
+
+      setError(null);
+
+      subscriptionRef.current?.remove();
+      subscriptionRef.current = addUpdateListener((state) => {
+        if (!mountedRef.current) return;
+
+        setDownloadProgress(state.downloadProgress);
+
+        if (state.installStatus === InstallStatus.DOWNLOADING) {
+          setIsDownloading(true);
+          setIsReadyToInstall(false);
+        } else if (state.installStatus === InstallStatus.DOWNLOADED) {
+          setIsDownloading(false);
+          setIsReadyToInstall(true);
+        } else if (
+          state.installStatus === InstallStatus.INSTALLED ||
+          state.installStatus === InstallStatus.FAILED ||
+          state.installStatus === InstallStatus.CANCELED
+        ) {
+          setIsDownloading(false);
+          if (state.installStatus !== InstallStatus.INSTALLED) {
+            setIsReadyToInstall(false);
+          }
+        }
+      });
+
+      try {
+        await startInAppUpdate(type);
+      } catch (e) {
+        const appError =
+          e instanceof AppUpdateError
+            ? e
+            : new AppUpdateError(AppUpdateErrorCode.UPDATE_FAILED, String(e));
+        setError(appError);
+        options?.onError?.(appError);
+      }
+    },
+    [options?.onError],
+  );
+
+  const handleCompleteUpdate = useCallback(async () => {
+    if (Platform.OS !== 'android') return;
+
+    try {
+      completeInAppUpdate();
+    } catch (e) {
+      const appError =
+        e instanceof AppUpdateError
+          ? e
+          : new AppUpdateError(AppUpdateErrorCode.UPDATE_FAILED, String(e));
+      setError(appError);
+      options?.onError?.(appError);
+    }
+  }, [options?.onError]);
+
+  // biome-ignore lint/correctness/useExhaustiveDependencies: checkOnMount is intentionally only checked once on mount
+  useEffect(() => {
+    mountedRef.current = true;
+
+    if (options?.checkOnMount) {
+      checkUpdate();
+    }
+
+    return () => {
+      mountedRef.current = false;
+      subscriptionRef.current?.remove();
+    };
+  }, []);
+
+  return {
+    isChecking,
+    isUpdateAvailable,
+    currentVersion,
+    latestVersion,
+    storeUrl,
+    error,
+    isDownloading,
+    downloadProgress,
+    isReadyToInstall,
+    playStoreInfo,
+    checkUpdate,
+    openStore: handleOpenStore,
+    startUpdate: handleStartUpdate,
+    completeUpdate: handleCompleteUpdate,
+  };
+}

package/src/index.ts

@@ -0,0 +1,36 @@
+export {
+  addUpdateListener,
+  checkPlayStoreUpdate,
+  completeInAppUpdate,
+  getAppStoreInfo,
+  getCountry,
+  getCurrentBuildNumber,
+  getCurrentVersion,
+  getLatestVersion,
+  getPackageName,
+  getStoreUrl,
+  needUpdate,
+  openStore,
+  startInAppUpdate,
+} from './api';
+export { useAppUpdate } from './hooks';
+export {
+  type AppStoreInfo,
+  AppUpdateError,
+  AppUpdateErrorCode,
+  type GetLatestVersionOptions,
+  type GetStoreUrlOptions,
+  type InstallState,
+  InstallStatus,
+  type NativeConstants,
+  type NativeUpdatesModuleType,
+  type NeedUpdateOptions,
+  type NeedUpdateResult,
+  type PlayStoreUpdateInfo,
+  UpdateAvailability,
+  type UpdateListener,
+  type UpdateSubscription,
+  UpdateType,
+  type UseAppUpdateOptions,
+  type UseAppUpdateResult,
+} from './types';