react-native-update 10.53.1 → 10.55.0

package/src/errorReporting.ts

@@ -0,0 +1,136 @@
+export type ErrorContextValue = string | number | boolean | null;
+
+export interface ErrorReportContext {
+  fatal?: boolean;
+  componentStack?: string;
+  extra?: Record<string, ErrorContextValue>;
+}
+
+export interface ErrorReportingOptions {
+  /** Install a chained React Native ErrorUtils handler. Default: true. */
+  captureGlobal?: boolean;
+}
+
+export interface SerializedException {
+  name: string;
+  message: string;
+  stack: string;
+  fatal: boolean;
+  componentStack?: string;
+  extra?: Record<string, ErrorContextValue>;
+}
+
+const MAX_NAME = 128;
+const MAX_MESSAGE = 2 * 1024;
+const MAX_STACK = 32 * 1024;
+const MAX_COMPONENT_STACK = 16 * 1024;
+const MAX_EXTRA_FIELDS = 32;
+const MAX_EXTRA_KEY = 64;
+const MAX_EXTRA_STRING = 1024;
+const MAX_EXTRA_JSON = 8 * 1024;
+
+const boundedString = (value: unknown, maximum: number) =>
+  typeof value === 'string' ? value.slice(0, maximum) : '';
+
+const normalizeExtra = (
+  extra?: Record<string, ErrorContextValue>
+): Record<string, ErrorContextValue> | undefined => {
+  if (!extra || typeof extra !== 'object') {
+    return undefined;
+  }
+  const result: Record<string, ErrorContextValue> = {};
+  for (const [rawKey, value] of Object.entries(extra).slice(
+    0,
+    MAX_EXTRA_FIELDS
+  )) {
+    const key = rawKey.slice(0, MAX_EXTRA_KEY);
+    if (!key) {
+      continue;
+    }
+    if (typeof value === 'string') {
+      result[key] = value.slice(0, MAX_EXTRA_STRING);
+    } else if (
+      value === null ||
+      typeof value === 'boolean' ||
+      (typeof value === 'number' && Number.isFinite(value))
+    ) {
+      result[key] = value;
+    }
+    // Keep the client comfortably inside the server's byte cap. The server
+    // remains authoritative because JS string length is not UTF-8 byte length.
+    if (JSON.stringify(result).length > MAX_EXTRA_JSON) {
+      delete result[key];
+      break;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+};
+
+export const serializeException = (
+  error: unknown,
+  context: ErrorReportContext = {}
+): SerializedException => {
+  const source =
+    error !== null && (typeof error === 'object' || typeof error === 'function')
+      ? (error as Record<string, unknown>)
+      : undefined;
+  const name = boundedString(source?.name, MAX_NAME).trim() || 'Error';
+  const message = (
+    boundedString(source?.message, MAX_MESSAGE) || String(error ?? '')
+  ).slice(0, MAX_MESSAGE);
+  const stack =
+    boundedString(source?.stack, MAX_STACK) || `${name}: ${message}`;
+  const componentStack = boundedString(
+    context.componentStack,
+    MAX_COMPONENT_STACK
+  );
+  const extra = normalizeExtra(context.extra);
+  return {
+    name,
+    message,
+    stack,
+    fatal: context.fatal === true,
+    ...(componentStack ? { componentStack } : {}),
+    ...(extra ? { extra } : {}),
+  };
+};
+
+type GlobalErrorHandler = (error: unknown, isFatal?: boolean) => void;
+
+interface GlobalErrorUtils {
+  getGlobalHandler?: () => GlobalErrorHandler;
+  setGlobalHandler?: (handler: GlobalErrorHandler) => void;
+}
+
+/**
+ * Install a React Native global error wrapper without taking ownership away
+ * from ExceptionsManager, Sentry, Crashlytics, or a handler installed later.
+ */
+export const installGlobalErrorHandler = (
+  capture: GlobalErrorHandler
+): (() => void) => {
+  const errorUtils = (globalThis as any).ErrorUtils as
+    | GlobalErrorUtils
+    | undefined;
+  if (
+    typeof errorUtils?.getGlobalHandler !== 'function' ||
+    typeof errorUtils.setGlobalHandler !== 'function'
+  ) {
+    return () => {};
+  }
+  const previous = errorUtils.getGlobalHandler();
+  const wrapper: GlobalErrorHandler = (error, isFatal) => {
+    try {
+      capture(error, isFatal);
+    } catch {
+      // Reporting must never alter React Native's original failure path.
+    }
+    previous?.(error, isFatal);
+  };
+  errorUtils.setGlobalHandler(wrapper);
+  return () => {
+    if (errorUtils.getGlobalHandler?.() === wrapper) {
+      errorUtils.setGlobalHandler?.(previous);
+    }
+  };
+};

package/src/index.ts

@@ -10,4 +10,18 @@ export {
 export { PushyModule, UpdateModule } from './core';
 export type { UpdateErrorCode } from './error';
 export { UpdateError } from './error';
+export type {
+  ErrorContextValue,
+  ErrorReportContext,
+  ErrorReportingOptions,
+  SerializedException,
+} from './errorReporting';
+export type { CrashReporterLike, UpdateMetadata } from './metadata';
+export {
+  attachToCrashlytics,
+  attachToSentry,
+  attachUpdateMetadata,
+  getUpdateMetadata,
+  updateMetadataTags,
+} from './metadata';
 export { PushyProvider, UpdateProvider } from './provider';

package/src/locales/en.ts

@@ -61,6 +61,9 @@ export default {
   error_all_promises_rejected: 'All promises were rejected',
   error_ping_failed: 'Ping failed',
   error_ping_timeout: 'Ping timeout',
+  error_insecure_redirect:
+    'Request was redirected from https to plaintext http',
+  error_invalid_check_response: 'Update check response is not a valid verdict',
   error_http_status: '{{status}} {{statusText}}',
   error_apk_pending_install:
     'The APK has been downloaded, please complete the installation in the system installer',

package/src/locales/zh.ts

@@ -58,6 +58,8 @@ export default {
   error_all_promises_rejected: '所有请求都被拒绝',
   error_ping_failed: 'Ping 失败',
   error_ping_timeout: 'Ping 超时',
+  error_insecure_redirect: '请求被从 https 重定向到明文 http',
+  error_invalid_check_response: '更新检查响应不是有效结果',
   error_http_status: '{{status}} {{statusText}}',
   error_apk_pending_install: '安装包已下载完成，请在系统安装界面完成安装',
   error_storage_permission_rejected: '存储权限被拒绝，无法下载安装包',

package/src/metadata.ts

@@ -0,0 +1,166 @@
+import {
+  buildTime,
+  cInfo,
+  currentBundleSha256,
+  currentVersion,
+  currentVersionInfo,
+  getBundleHash,
+  isFirstTime,
+  isRolledBack,
+  packageVersion,
+  rolledBackVersion,
+} from './core';
+
+/**
+ * Everything a crash report needs to be mapped back to the exact JS bundle
+ * that was running: attach it as tags/context in Sentry, Crashlytics, Bugly…
+ * The `currentVersion` hash (empty = the binary's embedded bundle) is the
+ * key that selects the matching source map on the update platform.
+ */
+export interface UpdateMetadata {
+  /** react-native-update SDK version. */
+  sdkVersion: string;
+  /** Native binary version the update decision is keyed on. */
+  packageVersion: string;
+  /** Build time of the native binary (empty in debug). */
+  buildTime: string;
+  /** Hash of the running hot-update version; '' when the embedded bundle runs. */
+  currentVersion: string;
+  /** Publisher-facing name/description/metaInfo of the running version. */
+  versionName: string;
+  versionDescription: string;
+  metaInfo: string;
+  /** SHA-256 of the embedded bundle; '' until computed / unavailable. */
+  bundleHash: string;
+  /**
+   * SHA-256 of the running hot-update bundle from its install record
+   * (matches the `bundleSha256` the CLI archives with the source map); ''
+   * for the embedded bundle or a legacy install.
+   */
+  bundleSha256: string;
+  /** First launch of `currentVersion` (crash protection still armed). */
+  isFirstTime: boolean;
+  /** This launch is the result of a rollback; `rolledBackVersion` names the culprit. */
+  isRolledBack: boolean;
+  rolledBackVersion: string;
+  /**
+   * How the running version got activated when not by the JS flow:
+   * 'forceBoot' — the server's per-version override applied by the native
+   * cold-start check; 'crashRescue' — activated by the crash-time rescue.
+   */
+  rescueSource: 'forceBoot' | 'crashRescue' | null;
+  /** Stable per-install client id (gray-release bucketing key). */
+  uuid: string;
+  os: string;
+}
+
+export function getUpdateMetadata(): UpdateMetadata {
+  const info = currentVersionInfo || {};
+  return {
+    sdkVersion: cInfo.rnu,
+    packageVersion,
+    buildTime,
+    currentVersion: currentVersion || '',
+    versionName: typeof info.name === 'string' ? info.name : '',
+    versionDescription:
+      typeof info.description === 'string' ? info.description : '',
+    metaInfo: typeof info.metaInfo === 'string' ? info.metaInfo : '',
+    bundleHash: getBundleHash(),
+    bundleSha256: currentBundleSha256 || '',
+    isFirstTime,
+    isRolledBack,
+    rolledBackVersion: rolledBackVersion || '',
+    rescueSource: info.forceBootRescue
+      ? 'forceBoot'
+      : info.crashRescue
+        ? 'crashRescue'
+        : null,
+    uuid: cInfo.uuid,
+    os: cInfo.os,
+  };
+}
+
+/**
+ * The duck-typed surface of a crash reporter. Sentry exposes setTag/setContext,
+ * Firebase Crashlytics setAttributes/setAttribute; any object with one of
+ * those works.
+ */
+export interface CrashReporterLike {
+  setTag?: (key: string, value: string) => unknown;
+  setContext?: (
+    name: string,
+    context: Record<string, unknown> | null
+  ) => unknown;
+  setAttributes?: (attributes: Record<string, string>) => unknown;
+  setAttribute?: (key: string, value: string) => unknown;
+}
+
+/** Flat string tags (`pushy.currentVersion` …) for the running update. */
+export function updateMetadataTags(
+  metadata: UpdateMetadata = getUpdateMetadata(),
+  prefix = 'pushy.'
+): Record<string, string> {
+  const tags: Record<string, string> = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    tags[`${prefix}${key}`] =
+      value === null || value === undefined ? '' : String(value);
+  }
+  return tags;
+}
+
+/**
+ * Attach the running update's metadata to a crash reporter so every event can
+ * be mapped to the exact bundle (and source map) it came from. Call once after
+ * the reporter is initialised; safe to call again (e.g. after markSuccess).
+ * Every reporter method is optional and failures are swallowed — a reporting
+ * hiccup must never break the app.
+ */
+export function attachUpdateMetadata(
+  reporter: CrashReporterLike,
+  options: { prefix?: string; contextName?: string | null } = {}
+): UpdateMetadata {
+  const metadata = getUpdateMetadata();
+  const tags = updateMetadataTags(metadata, options.prefix ?? 'pushy.');
+  const swallow = (fn: () => unknown) => {
+    try {
+      const result = fn();
+      if (result && typeof (result as Promise<unknown>).catch === 'function') {
+        (result as Promise<unknown>).catch(() => {});
+      }
+    } catch {
+      // never let a reporter failure propagate
+    }
+  };
+  if (typeof reporter.setTag === 'function') {
+    for (const [key, value] of Object.entries(tags)) {
+      swallow(() => reporter.setTag?.(key, value));
+    }
+  } else if (typeof reporter.setAttributes === 'function') {
+    swallow(() => reporter.setAttributes?.(tags));
+  } else if (typeof reporter.setAttribute === 'function') {
+    for (const [key, value] of Object.entries(tags)) {
+      swallow(() => reporter.setAttribute?.(key, value));
+    }
+  }
+  if (
+    options.contextName !== null &&
+    typeof reporter.setContext === 'function'
+  ) {
+    swallow(() =>
+      reporter.setContext?.(options.contextName ?? 'pushy', { ...metadata })
+    );
+  }
+  return metadata;
+}
+
+/** `attachUpdateMetadata` for `@sentry/react-native` (tags + a `pushy` context). */
+export function attachToSentry(sentry: CrashReporterLike): UpdateMetadata {
+  return attachUpdateMetadata(sentry, { contextName: 'pushy' });
+}
+
+/** `attachUpdateMetadata` for `@react-native-firebase/crashlytics` (custom keys). */
+export function attachToCrashlytics(
+  crashlytics: CrashReporterLike
+): UpdateMetadata {
+  return attachUpdateMetadata(crashlytics, { contextName: null });
+}

package/src/provider.tsx

@@ -343,13 +343,36 @@ export const UpdateProvider = ({
     if (!assertWeb()) {
       return;
     }
-    const { checkStrategy, autoMarkSuccess } = options;
+    const { checkStrategy, autoMarkSuccess, autoMarkSuccessDelayMs } = options;
     let markSuccessTimer: ReturnType<typeof setTimeout> | undefined;
     if (autoMarkSuccess) {
+      const delay =
+        typeof autoMarkSuccessDelayMs === 'number' &&
+        autoMarkSuccessDelayMs >= 0
+          ? autoMarkSuccessDelayMs
+          : 1000;
       markSuccessTimer = setTimeout(() => {
-        // Failures are reported and surfaced via the onError subscription.
-        Promise.resolve(markSuccess()).catch(noop);
-      }, 1000);
+        // The health check is read when the timer fires, not when it was
+        // armed, so a late setOptions still applies.
+        const { healthCheck } = options;
+        (async () => {
+          if (healthCheck) {
+            let healthy = false;
+            try {
+              healthy = (await healthCheck()) !== false;
+            } catch (e: any) {
+              log('healthCheck threw, not marking success:', e?.message || e);
+              return;
+            }
+            if (!healthy) {
+              log('healthCheck returned false, not marking success');
+              return;
+            }
+          }
+          // Failures are reported and surfaced via the onError subscription.
+          await markSuccess();
+        })().catch(noop);
+      }, delay);
     }
     if (checkStrategy === 'both' || checkStrategy === 'onAppResume') {
       stateListener.current = AppState.addEventListener(
@@ -396,30 +419,42 @@ export const UpdateProvider = ({
   const parseTestPayload = useCallback(
     (payload: UpdateTestPayload) => {
       if (payload?.type?.startsWith('__rnPushy')) {
+        if (options.testChannel === false) {
+          // Production builds may refuse scanned codes that would pull an
+          // arbitrary published version.
+          log('test channel disabled, ignoring payload', payload.type);
+          return false;
+        }
         if (payload.type === '__rnPushyVersionHash') {
-          // Wrap the logger only for the duration of this test check; wrapping
-          // on any other __rnPushy* payload would never be undone (the finally
-          // below is the only restore point).
-          const logger = options.logger || (() => {});
-          options.logger = ({ type, data }) => {
-            logger({ type, data });
-            Alert.alert(type, JSON.stringify(data));
-          };
           const toHash = payload.data;
+          if (typeof toHash !== 'string' || !toHash) {
+            log('test payload without a target hash ignored');
+            return false;
+          }
           sharedState.toHash = toHash;
+          // No global logger swap for the duration of the check (it leaked
+          // into concurrent checks): the tester gets one alert with the
+          // outcome instead of one per logged event.
           checkUpdate({ extra: { toHash } })
             .then(() => {
-              if (updateInfoRef.current?.upToDate) {
+              const info = updateInfoRef.current;
+              if (info?.upToDate) {
                 Alert.alert(
                   client.t('alert_info'),
                   client.t('alert_no_update_wait')
                 );
+              } else if (info?.update) {
+                Alert.alert(
+                  client.t('alert_info'),
+                  JSON.stringify({
+                    hash: info.hash,
+                    name: info.name,
+                    description: info.description,
+                  })
+                );
               }
             })
-            .catch(noop)
-            .finally(() => {
-              options.logger = logger;
-            });
+            .catch(noop);
         }
         return true;
       }

package/src/type.ts

@@ -162,6 +162,28 @@ export interface ClientOptions {
     | null;
   checkStrategy?: 'onAppStart' | 'onAppResume' | 'both' | null;
   autoMarkSuccess?: boolean;
+  /**
+   * Delay before the Provider marks the running update as successful when
+   * `autoMarkSuccess` is on. Default 1000ms. Apps whose critical modules load
+   * after the first frame (navigation, remote config) should raise it — a
+   * version that crashes 3s after mount would otherwise already be marked
+   * good and never rolled back. For full control use `autoMarkSuccess: false`
+   * and call `markSuccess()` once the app is really ready.
+   */
+  autoMarkSuccessDelayMs?: number;
+  /**
+   * Consulted when the auto-mark timer fires: return false (or throw) to
+   * skip marking this launch — the next launch's crash protection then still
+   * applies. Call `markSuccess()` yourself later once the app is healthy.
+   */
+  healthCheck?: () => boolean | Promise<boolean>;
+  /**
+   * Whether the Provider honours test-channel payloads (`parseTestQrCode`,
+   * `__rnPushyVersionHash` deep links / QR codes) that target a specific
+   * version hash. Default true. Set to false in production builds that must
+   * not let a scanned code pull an arbitrary published version.
+   */
+  testChannel?: boolean;
   dismissErrorAfter?: number;
   debug?: boolean;
   throwError?: boolean;
@@ -183,6 +205,13 @@ export interface ClientOptions {
    * the version health view in the console. Default: false (enabled).
    */
   disableTelemetry?: boolean;
+  /**
+   * Disable automatic and manual JavaScript exception reporting. Reporting is
+   * enabled by default and chains React Native's existing global ErrorUtils
+   * handler. Set this to true for an explicit opt-out; update lifecycle
+   * telemetry remains controlled separately by `disableTelemetry`.
+   */
+  disableErrorReporting?: boolean;
   /**
    * Disable the native cold-start update check: the background check that runs
    * a few seconds after every launch, independent of JS

package/src/updateFlowCore.ts

@@ -172,22 +172,113 @@ export function buildCheckRequestBody({
   isDev,
   extra,
 }: CheckRequestInput): Record<string, any> {
+  // Caller extras are spread FIRST so they can add fields (channel, custom
+  // filters, the debug-channel toHash) but never override the SDK identity
+  // fields the server keys its decision on: a stray `packageVersion` or
+  // `hash` in extra would otherwise make the server hand out a package for
+  // the wrong binary.
   const body: Record<string, any> = {
+    ...extra,
     packageVersion,
     hash: currentVersion,
     buildTime,
     cInfo,
-    // 可消费的 diff 轨道版本(2 = hdiffv2 轨道),服务端据此门控下发
-    ...(supportedDiffVersion ? { diffV: supportedDiffVersion } : {}),
-    ...(bundleHash ? { bundleHash } : {}),
-    ...extra,
   };
+  // 可消费的 diff 轨道版本(2 = hdiffv2 轨道),服务端据此门控下发
+  if (supportedDiffVersion) {
+    body.diffV = supportedDiffVersion;
+  } else {
+    delete body.diffV;
+  }
+  if (bundleHash) {
+    body.bundleHash = bundleHash;
+  } else {
+    delete body.bundleHash;
+  }
   if (isDev) {
     delete body.buildTime;
   }
+  // Transitional dual form: the legacy root-level spread above is what
+  // servers before 2026-08-30 read; the nested copy is what new servers read
+  // first (extra.toHash wins there) and lets caller keys stop sharing the
+  // SDK's namespace once the root spread is retired.
+  if (extra) {
+    // Match JSON.stringify semantics: undefined values do not exist on the
+    // wire, so they must not create a nested copy either (the native check
+    // cache compares serialized requests).
+    const defined: Record<string, any> = {};
+    for (const [key, value] of Object.entries(extra)) {
+      if (value !== undefined) {
+        defined[key] = value;
+      }
+    }
+    if (Object.keys(defined).length > 0) {
+      body.extra = defined;
+    }
+  }
   return body;
 }
 
+export interface CheckFingerprintInput {
+  appKey?: string;
+  endpoints?: string[];
+  queryUrls?: string[];
+  uuid?: string;
+  /** The exact serialized request body (identity fields + extra). */
+  body: string;
+}
+
+/**
+ * Identity of one update check. Two checks may share an in-flight response
+ * only when every input that could change the server's answer is identical.
+ */
+export function buildCheckFingerprint({
+  appKey,
+  endpoints,
+  queryUrls,
+  uuid,
+  body,
+}: CheckFingerprintInput): string {
+  return JSON.stringify([
+    appKey ?? '',
+    endpoints ?? [],
+    queryUrls ?? [],
+    uuid ?? '',
+    body,
+  ]);
+}
+
+/**
+ * Whether a failed download attempt is worth retrying on another mirror of
+ * the same artifact. Transport failures (DNS, connect, timeout, truncated
+ * body, 5xx) and corrupt bytes are; a patch that downloaded fine but could
+ * not be applied is not — every mirror serves the same bytes, so the next
+ * strategy is the only way forward.
+ */
+export function isMirrorRetryableCode(code?: string): boolean {
+  return code !== 'PATCH_FAILED';
+}
+
+/**
+ * Schema gate for a checkUpdate response (mirrors C++ IsValidCheckResult): a
+ * JSON object carrying at least one verdict field of the expected type —
+ * `upToDate` / `update` / `expired` (boolean) or `paused` (string). A 200
+ * with `{"error": ...}`, an array or an HTML page that happened to parse is
+ * a failed endpoint, not a verdict, and must not stop the endpoint fallback.
+ */
+export function isValidCheckResult(value: unknown): value is CheckResult {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+  const root = value as Record<string, unknown>;
+  return (
+    typeof root.upToDate === 'boolean' ||
+    typeof root.update === 'boolean' ||
+    typeof root.expired === 'boolean' ||
+    typeof root.paused === 'string'
+  );
+}
+
 export interface UpdateIdentity {
   packageVersion: string;
   currentVersion?: string;

package/src/utils.ts

@@ -66,6 +66,13 @@ const ping = isWeb
           DEFAULT_FETCH_TIMEOUT_MS
         );
         if (status === 200) {
+          if (isProtocolDowngrade(url, finalUrl)) {
+            // The probe was redirected from https to plaintext http. Never
+            // let a downgraded final URL win the race: the winner is what
+            // the real artifact download uses.
+            log('ping rejected: https redirected to http', url, finalUrl);
+            throw Error(i18n.t('error_ping_failed'));
+          }
           return finalUrl;
         }
         log('ping failed', url, status, statusText);
@@ -166,29 +173,34 @@ export const fetchWithTimeout = (
     });
 };
 
-const isIdempotentRequest = (params: Parameters<typeof fetch>[1]) => {
-  const method = params?.method?.toUpperCase() ?? 'GET';
-  return method === 'GET' || method === 'HEAD';
-};
+/**
+ * True when `finalUrl` (after redirects) is plaintext http while the request
+ * started on https. An https endpoint or artifact URL must never be served
+ * over http, redirected or otherwise: the update package is the supply chain
+ * boundary, and TLS is the only thing authenticating it.
+ */
+export const isProtocolDowngrade = (
+  requestedUrl: string,
+  finalUrl?: string | null
+): boolean =>
+  !!finalUrl && /^https:/i.test(requestedUrl) && /^http:/i.test(finalUrl);
 
 export const enhancedFetch = async (
   url: string,
-  params: Parameters<typeof fetch>[1],
-  isRetry = false
+  params: Parameters<typeof fetch>[1]
 ): Promise<Response> => {
-  return fetch(url, params).catch((e) => {
+  // No https -> http retry here, ever. Earlier versions replayed failed
+  // idempotent https requests over plaintext http as a "network
+  // compatibility" fallback; that silently moved endpoint discovery and
+  // package downloads outside TLS. Self-hosted plaintext deployments must
+  // configure explicit http:// URLs instead.
+  const response = await fetch(url, params).catch((e) => {
     log('fetch error', url, e);
-    if (
-      isRetry ||
-      (params as any)?.signal?.aborted ||
-      !url.startsWith('https:') ||
-      // Never replay non-idempotent requests (e.g. the checkUpdate POST)
-      // over plaintext http: the server may have processed the original.
-      !isIdempotentRequest(params)
-    ) {
-      throw e;
-    }
-    log('trying fallback to http');
-    return enhancedFetch(url.replace(/^https:/, 'http:'), params, true);
+    throw e;
   });
+  if (isProtocolDowngrade(url, response?.url)) {
+    log('fetch rejected: https redirected to http', url, response.url);
+    throw Error(i18n.t('error_insecure_redirect'));
+  }
+  return response;
 };

package/.gitmodules

@@ -1,6 +0,0 @@
-[submodule "android/jni/lzma"]
-	path = android/jni/lzma
-	url = https://github.com/sisong/lzma.git
-[submodule "android/jni/HDiffPatch"]
-	path = android/jni/HDiffPatch
-	url = https://github.com/sisong/HDiffPatch.git