Update configuration for HarmonyOS support by changing Jest preset and enhancing Metro configuration. Add new scripts for Harmony build processes and update package dependencies to align with Harmony template packages. Improve test coverage for document handling and refine portal document download logic for better progress tracking.

Author: shuai.jiang

__tests__/deviceState.test.ts

@@ -0,0 +1,48 @@
+describe('deviceState platform adapter', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.resetModules();
+  });
+
+  test('disables the idle timer on iOS when requested', () => {
+    const setIdleTimerDisabled = jest.fn();
+
+    jest.doMock('react-native', () => ({
+      NativeModules: {
+        FPDeviceState: {
+          setIdleTimerDisabled,
+        },
+      },
+      Platform: {
+        OS: 'ios',
+      },
+    }));
+
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const {setPlatformIdleTimerDisabled} = require('../src/platform/deviceState');
+
+    setPlatformIdleTimerDisabled(true);
+    expect(setIdleTimerDisabled).toHaveBeenCalledWith(true);
+  });
+
+  test('does nothing outside iOS', () => {
+    const setIdleTimerDisabled = jest.fn();
+
+    jest.doMock('react-native', () => ({
+      NativeModules: {
+        FPDeviceState: {
+          setIdleTimerDisabled,
+        },
+      },
+      Platform: {
+        OS: 'android',
+      },
+    }));
+
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const {setPlatformIdleTimerDisabled} = require('../src/platform/deviceState');
+
+    setPlatformIdleTimerDisabled(true);
+    expect(setIdleTimerDisabled).not.toHaveBeenCalled();
+  });
+});

__tests__/harmonyPlatformAdapters.test.ts

@@ -0,0 +1,84 @@
+describe('Harmony platform adapters', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.resetModules();
+  });
+
+  test('uses the file picker as a media-import fallback on Harmony', async () => {
+    const pickDeviceFilesForShare = jest.fn().mockResolvedValue([{id: 'file'}]);
+    const pickDeviceMediaForShare = jest.fn();
+
+    jest.doMock('react-native', () => ({
+      Platform: {
+        OS: 'harmony',
+      },
+    }));
+    jest.doMock('../src/modules/file-access/reactNativeAdapters', () => ({
+      cleanupImportedDeviceFiles: jest.fn(),
+      consumePendingSharedItems: jest.fn(),
+      createReactNativeInboundStorageGateway: jest.fn(),
+      exportPreparedFile: jest.fn(),
+      exportStoredFile: jest.fn(),
+      pickDeviceFilesForShare,
+      pickDeviceMediaForShare,
+    }));
+
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const {pickPlatformMediaForShare} = require('../src/platform/fileAccess');
+
+    await expect(pickPlatformMediaForShare()).resolves.toEqual([{id: 'file'}]);
+    expect(pickDeviceFilesForShare).toHaveBeenCalledTimes(1);
+    expect(pickDeviceMediaForShare).not.toHaveBeenCalled();
+  });
+
+  test('selects the TCP socket runtime on Harmony', () => {
+    const harmonyRuntime = {
+      isRunning: jest.fn(),
+      start: jest.fn(),
+    };
+    const nativeRuntime = {
+      isRunning: jest.fn(),
+      start: jest.fn(),
+    };
+    const createReactNativeTcpHttpRuntime = jest.fn(() => harmonyRuntime);
+    const createReactNativeHttpRuntime = jest.fn(() => nativeRuntime);
+
+    jest.doMock('react-native', () => ({
+      Platform: {
+        OS: 'harmony',
+      },
+    }));
+    jest.doMock('../src/modules/service/reactNativeTcpHttpRuntime', () => ({
+      createReactNativeTcpHttpRuntime,
+    }));
+    jest.doMock('../src/modules/service/reactNativeHttpRuntime', () => ({
+      createReactNativeHttpRuntime,
+    }));
+
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const {createPlatformServiceRuntime} = require('../src/platform/serviceRuntime');
+
+    expect(createPlatformServiceRuntime()).toBe(harmonyRuntime);
+    expect(createReactNativeTcpHttpRuntime).toHaveBeenCalledTimes(1);
+    expect(createReactNativeHttpRuntime).not.toHaveBeenCalled();
+  });
+
+  test('writes to the clipboard on Harmony without throwing', () => {
+    const setString = jest.fn();
+
+    jest.doMock('react-native', () => ({
+      Platform: {
+        OS: 'harmony',
+      },
+    }));
+    jest.doMock('@react-native-clipboard/clipboard', () => ({
+      setString,
+    }));
+
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const {setClipboardString} = require('../src/platform/clipboard');
+
+    expect(() => setClipboardString('hello harmony')).not.toThrow();
+    expect(setString).toHaveBeenCalledWith('hello harmony');
+  });
+});

__tests__/portalDocument.test.ts

@@ -23,6 +23,8 @@ describe('buildPortalDocument', () => {
     expect(html).toContain("state.phase === 'downloading'");
     expect(html).toContain('await Promise.all(');
     expect(html).toContain('downloadedChunks[descriptor.index] = chunk;');
+    expect(html).toContain('response.body?.getReader?.()');
+    expect(html).toContain('const chunkProgressByIndex = new Array(chunkPlan.length).fill(0);');
     expect(html).toContain('setTimeout(() => URL.revokeObjectURL(objectUrl), 60000);');
     expect(html).not.toContain('浏览器投递');
     expect(html).not.toContain('hero-copy');

__tests__/reactNativeAdapters.test.ts

@@ -189,4 +189,97 @@ describe('ReactNativeFileSystemAdapter', () => {
       'base64',
     );
   });
+
+  test('reads pending shared items from the Harmony inbox manifest when the native bridge is unavailable', async () => {
+    jest.resetModules();
+
+    const exists = jest.fn().mockResolvedValue(true);
+    const readFile = jest.fn().mockResolvedValue(
+      JSON.stringify({
+        files: [
+          {
+            byteLength: 12,
+            createdAt: '2026-04-29T12:00:00.000Z',
+            mimeType: 'text/plain',
+            name: 'notes.txt',
+            relativePath: 'notes.txt',
+            sourcePath: '/sandbox/cache/ffb-inbound/notes.txt',
+          },
+        ],
+        texts: [
+          {
+            content: 'Shared note',
+            createdAt: '2026-04-29T12:00:00.000Z',
+          },
+        ],
+      }),
+    );
+    const unlink = jest.fn().mockResolvedValue(undefined);
+
+    jest.doMock('react-native', () => ({
+      NativeModules: {},
+      Platform: {
+        OS: 'harmony',
+      },
+    }));
+    jest.doMock('../src/platform/documentPicker', () => ({
+      documentPickerErrorCodes: {
+        OPERATION_CANCELED: 'DOCUMENT_PICKER_CANCELED',
+      },
+      documentPickerTypes: {
+        allFiles: '*/*',
+      },
+      isDocumentPickerErrorWithCode: jest.fn(),
+      pickDocuments: jest.fn(),
+      savePickedDocuments: jest.fn(),
+    }));
+    jest.doMock('react-native-share', () => ({
+      __esModule: true,
+      default: {},
+    }));
+    jest.doMock('react-native-fs', () => ({
+      __esModule: true,
+      default: {
+        DocumentDirectoryPath: '/sandbox/files',
+        exists,
+        mkdir: jest.fn(),
+        readFile,
+        unlink,
+      },
+    }));
+    jest.doMock('pako', () => ({
+      gzip: jest.fn(),
+      ungzip: jest.fn(),
+    }));
+
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const {consumePendingSharedItems} = require('../src/modules/file-access/reactNativeAdapters');
+
+    await expect(consumePendingSharedItems()).resolves.toEqual({
+      files: [
+        {
+          byteLength: 12,
+          cleanupPath: '/sandbox/cache/ffb-inbound/notes.txt',
+          createdAt: '2026-04-29T12:00:00.000Z',
+          mimeType: 'text/plain',
+          name: 'notes.txt',
+          relativePath: 'notes.txt',
+          sourcePath: '/sandbox/cache/ffb-inbound/notes.txt',
+        },
+      ],
+      texts: [
+        {
+          content: 'Shared note',
+          createdAt: '2026-04-29T12:00:00.000Z',
+        },
+      ],
+    });
+
+    expect(exists).toHaveBeenCalledWith('/sandbox/files/ffb-inbound/pending.json');
+    expect(readFile).toHaveBeenCalledWith(
+      '/sandbox/files/ffb-inbound/pending.json',
+      'utf8',
+    );
+    expect(unlink).toHaveBeenCalledWith('/sandbox/files/ffb-inbound/pending.json');
+  });
 });

__tests__/reactNativeTcpHttpRuntime.test.ts

@@ -0,0 +1,86 @@
+import {
+  encodeHttpResponse,
+  parseHttpRequestFrame,
+} from '../src/modules/service/reactNativeTcpHttpRuntime';
+
+function decodeAscii(bytes: Uint8Array) {
+  return Array.from(bytes)
+    .map(value => String.fromCharCode(value))
+    .join('');
+}
+
+describe('parseHttpRequestFrame', () => {
+  test('returns null until the full request body arrives', () => {
+    const partial = new TextEncoder().encode(
+      'POST /api/text HTTP/1.1\r\nContent-Type: text/plain\r\nContent-Length: 5\r\n\r\nhe',
+    );
+
+    expect(parseHttpRequestFrame(partial)).toBeNull();
+  });
+
+  test('parses method, query, headers, and text body', () => {
+    const requestBytes = new TextEncoder().encode(
+      'POST /api/text?key=abc HTTP/1.1\r\nContent-Type: text/plain; charset=utf-8\r\nX-Client-Id: browser-a\r\nContent-Length: 5\r\n\r\nhello',
+    );
+
+    const parsed = parseHttpRequestFrame(requestBytes);
+
+    expect(parsed).not.toBeNull();
+    expect(parsed?.consumedBytes).toBe(requestBytes.byteLength);
+    expect(parsed?.request.method).toBe('POST');
+    expect(parsed?.request.path).toBe('/api/text');
+    expect(parsed?.request.query.get('key')).toBe('abc');
+    expect(parsed?.request.headers['x-client-id']).toBe('browser-a');
+    expect(parsed?.request.body).toBe('hello');
+  });
+});
+
+describe('encodeHttpResponse', () => {
+  test('adds content length and connection headers for json responses', () => {
+    const responseBytes = encodeHttpResponse({
+      body: {
+        ok: true,
+      },
+      headers: {
+        'content-type': 'application/json; charset=utf-8',
+      },
+      status: 200,
+    });
+
+    const headerEnd = decodeAscii(responseBytes).indexOf('\r\n\r\n');
+    expect(headerEnd).toBeGreaterThan(0);
+
+    const headerText = decodeAscii(responseBytes.slice(0, headerEnd));
+    const bodyText = new TextDecoder('utf-8').decode(
+      responseBytes.slice(headerEnd + 4),
+    );
+
+    expect(headerText).toContain('HTTP/1.1 200 OK');
+    expect(headerText).toContain('content-type: application/json; charset=utf-8');
+    expect(headerText).toContain('connection: close');
+    expect(headerText).toContain(`content-length: ${bodyText.length}`);
+    expect(bodyText).toBe(JSON.stringify({ok: true}));
+  });
+
+  test('encodes base64-backed binary payloads', () => {
+    const responseBytes = encodeHttpResponse({
+      body: {
+        base64: Buffer.from('chunk-data', 'utf8').toString('base64'),
+        byteLength: 10,
+        kind: 'base64',
+      },
+      headers: {
+        'content-type': 'application/octet-stream',
+      },
+      status: 206,
+    });
+
+    const headerEnd = decodeAscii(responseBytes).indexOf('\r\n\r\n');
+    const bodyBytes = responseBytes.slice(headerEnd + 4);
+
+    expect(decodeAscii(responseBytes.slice(0, headerEnd))).toContain(
+      'HTTP/1.1 206 Partial Content',
+    );
+    expect(Buffer.from(bodyBytes).toString('utf8')).toBe('chunk-data');
+  });
+});