feat(native): record encoding (#14188)

fix #13784  ## Summary by CodeRabbit * **New Features** * Start/stop system or meeting recordings with Ogg/Opus artifacts and native start/stop APIs; workspace backup recovery. * **Refactor** * Simplified recording lifecycle and UI flows; native runtime now orchestrates recording/processing and reporting. * **Bug Fixes** * Stronger path validation, safer import/export dialogs, consistent error handling/logging, and retry-safe recording processing. * **Chores** * Added cross-platform native audio capture and Ogg/Opus encoding support. * **Tests** * New unit, integration, and e2e tests for recording, path guards, dialogs, and workspace recovery.
2026-07-29 08:09:52 +08:00 · 2026-03-22 02:50:14 +08:00
parent 6a93566422
commit bcf2a51d41
44 changed files with 2921 additions and 1143 deletions
@@ -0,0 +1,256 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+
+const isActiveTab = vi.fn();
+const readRecordingFile = vi.fn();
+const setRecordingBlockCreationStatus = vi.fn();
+const getCurrentWorkspace = vi.fn();
+const isAiEnabled = vi.fn();
+const transcribeRecording = vi.fn();
+
+let onRecordingStatusChanged:
+  | ((
+      status: {
+        id: number;
+        status: 'processing';
+        appName?: string;
+        filepath?: string;
+        startTime: number;
+        blockCreationStatus?: 'success' | 'failed';
+      } | null
+    ) => void)
+  | undefined;
+
+vi.mock('@affine/core/modules/doc', () => ({
+  DocsService: class DocsService {},
+}));
+
+vi.mock('@affine/core/modules/media/services/audio-attachment', () => ({
+  AudioAttachmentService: class AudioAttachmentService {},
+}));
+
+vi.mock('@affine/core/modules/workbench', () => ({
+  WorkbenchService: class WorkbenchService {},
+}));
+
+vi.mock('@affine/debug', () => ({
+  DebugLogger: class DebugLogger {
+    debug = vi.fn();
+    error = vi.fn();
+  },
+}));
+
+vi.mock('@affine/electron-api', () => ({
+  apis: {
+    ui: {
+      isActiveTab,
+    },
+    recording: {
+      readRecordingFile,
+      setRecordingBlockCreationStatus,
+    },
+  },
+  events: {
+    recording: {
+      onRecordingStatusChanged: vi.fn(
+        (handler: typeof onRecordingStatusChanged) => {
+          onRecordingStatusChanged = handler;
+          return () => {
+            onRecordingStatusChanged = undefined;
+          };
+        }
+      ),
+    },
+  },
+}));
+
+vi.mock('@affine/i18n', () => ({
+  i18nTime: vi.fn(() => 'Jan 1 09:00'),
+}));
+
+vi.mock('@affine/track', () => ({
+  default: {
+    doc: {
+      editor: {
+        audioBlock: {
+          transcribeRecording,
+        },
+      },
+    },
+  },
+}));
+
+vi.mock('../../../electron-renderer/src/app/effects/utils', () => ({
+  getCurrentWorkspace,
+  isAiEnabled,
+}));
+
+function createWorkspaceRef() {
+  const blobSet = vi.fn(async () => 'blob-1');
+  const addBlock = vi.fn(() => 'attachment-1');
+  const getBlock = vi.fn(() => ({ model: { id: 'attachment-1' } }));
+  const openDoc = vi.fn();
+
+  type MockDoc = {
+    workspace: {
+      blobSync: {
+        set: typeof blobSet;
+      };
+    };
+    addBlock: typeof addBlock;
+    getBlock: typeof getBlock;
+  };
+
+  type MockDocProps = {
+    onStoreLoad: (doc: MockDoc, meta: { noteId: string }) => void;
+  };
+
+  const createDoc = vi.fn(({ docProps }: { docProps: MockDocProps }) => {
+    queueMicrotask(() => {
+      docProps.onStoreLoad(
+        {
+          workspace: { blobSync: { set: blobSet } },
+          addBlock,
+          getBlock,
+        },
+        { noteId: 'note-1' }
+      );
+    });
+
+    return { id: 'doc-1' };
+  });
+
+  const scope = {
+    get(token: { name?: string }) {
+      switch (token.name) {
+        case 'DocsService':
+          return { createDoc };
+        case 'WorkbenchService':
+          return { workbench: { openDoc } };
+        case 'AudioAttachmentService':
+          return {
+            get: () => ({
+              obj: {
+                transcribe: vi.fn(async () => undefined),
+              },
+              [Symbol.dispose]: vi.fn(),
+            }),
+          };
+        default:
+          throw new Error(`Unexpected token: ${token.name}`);
+      }
+    },
+  };
+
+  const dispose = vi.fn();
+
+  return {
+    ref: {
+      workspace: { scope },
+      dispose,
+      [Symbol.dispose]: dispose,
+    },
+    createDoc,
+    openDoc,
+    blobSet,
+    addBlock,
+    getBlock,
+  };
+}
+
+describe('recording effect', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.clearAllMocks();
+    vi.resetModules();
+    onRecordingStatusChanged = undefined;
+    readRecordingFile.mockResolvedValue(new Uint8Array([1, 2, 3]).buffer);
+    setRecordingBlockCreationStatus.mockResolvedValue(undefined);
+    isAiEnabled.mockReturnValue(false);
+  });
+
+  afterEach(() => {
+    vi.runOnlyPendingTimers();
+    vi.useRealTimers();
+  });
+
+  test('retries processing until the active tab has a workspace', async () => {
+    const workspace = createWorkspaceRef();
+
+    isActiveTab.mockResolvedValueOnce(false).mockResolvedValue(true);
+    getCurrentWorkspace
+      .mockReturnValueOnce(undefined)
+      .mockReturnValue(workspace.ref);
+
+    const { setupRecordingEvents } =
+      await import('../../../electron-renderer/src/app/effects/recording');
+
+    setupRecordingEvents({} as never);
+
+    onRecordingStatusChanged?.({
+      id: 7,
+      status: 'processing',
+      appName: 'Zoom',
+      filepath: '/tmp/meeting.opus',
+      startTime: 1000,
+    });
+
+    await Promise.resolve();
+    expect(workspace.createDoc).not.toHaveBeenCalled();
+    expect(setRecordingBlockCreationStatus).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(workspace.createDoc).not.toHaveBeenCalled();
+    expect(setRecordingBlockCreationStatus).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1000);
+
+    expect(workspace.createDoc).toHaveBeenCalledTimes(1);
+    expect(workspace.openDoc).toHaveBeenCalledWith('doc-1');
+    expect(workspace.blobSet).toHaveBeenCalledTimes(1);
+    const [savedBlob] = workspace.blobSet.mock.calls[0] ?? [];
+    expect(savedBlob).toBeInstanceOf(Blob);
+    expect((savedBlob as Blob).type).toBe('audio/ogg');
+    expect(workspace.addBlock).toHaveBeenCalledWith(
+      'affine:attachment',
+      expect.objectContaining({ type: 'audio/ogg' }),
+      'note-1'
+    );
+    expect(setRecordingBlockCreationStatus).toHaveBeenCalledWith(7, 'success');
+    expect(setRecordingBlockCreationStatus).not.toHaveBeenCalledWith(
+      7,
+      'failed',
+      expect.anything()
+    );
+  });
+
+  test('retries when the active-tab probe rejects', async () => {
+    const workspace = createWorkspaceRef();
+
+    isActiveTab
+      .mockRejectedValueOnce(new Error('probe failed'))
+      .mockResolvedValue(true);
+    getCurrentWorkspace.mockReturnValue(workspace.ref);
+
+    const { setupRecordingEvents } =
+      await import('../../../electron-renderer/src/app/effects/recording');
+
+    setupRecordingEvents({} as never);
+
+    onRecordingStatusChanged?.({
+      id: 9,
+      status: 'processing',
+      appName: 'Meet',
+      filepath: '/tmp/meeting.opus',
+      startTime: 1000,
+    });
+
+    await Promise.resolve();
+    expect(workspace.createDoc).not.toHaveBeenCalled();
+    expect(setRecordingBlockCreationStatus).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1000);
+
+    expect(workspace.createDoc).toHaveBeenCalledTimes(1);
+    expect(setRecordingBlockCreationStatus).toHaveBeenCalledWith(9, 'success');
+  });
+});
@@ -0,0 +1,116 @@
+import { describe, expect, test, vi } from 'vitest';
+
+vi.mock('../../src/main/logger', () => ({
+  logger: {
+    error: vi.fn(),
+    info: vi.fn(),
+  },
+}));
+
+import { RecordingStateMachine } from '../../src/main/recording/state-machine';
+
+function createAttachedRecording(stateMachine: RecordingStateMachine) {
+  const pending = stateMachine.dispatch({
+    type: 'START_RECORDING',
+  });
+
+  stateMachine.dispatch({
+    type: 'ATTACH_NATIVE_RECORDING',
+    id: pending!.id,
+    nativeId: 'native-1',
+    startTime: 100,
+    filepath: '/tmp/recording.opus',
+    sampleRate: 48000,
+    numberOfChannels: 2,
+  });
+
+  return pending!;
+}
+
+describe('RecordingStateMachine', () => {
+  test('transitions from recording to ready after artifact import and block creation', () => {
+    const stateMachine = new RecordingStateMachine();
+
+    const pending = createAttachedRecording(stateMachine);
+    expect(pending?.status).toBe('recording');
+
+    const processing = stateMachine.dispatch({
+      type: 'STOP_RECORDING',
+      id: pending.id,
+    });
+    expect(processing?.status).toBe('processing');
+
+    const artifactAttached = stateMachine.dispatch({
+      type: 'ATTACH_RECORDING_ARTIFACT',
+      id: pending.id,
+      filepath: '/tmp/recording.opus',
+      sampleRate: 48000,
+      numberOfChannels: 2,
+    });
+    expect(artifactAttached).toMatchObject({
+      status: 'processing',
+      filepath: '/tmp/recording.opus',
+    });
+
+    const ready = stateMachine.dispatch({
+      type: 'SET_BLOCK_CREATION_STATUS',
+      id: pending.id,
+      status: 'success',
+    });
+    expect(ready).toMatchObject({
+      status: 'ready',
+      blockCreationStatus: 'success',
+    });
+  });
+
+  test('keeps native audio metadata when stop artifact omits it', () => {
+    const stateMachine = new RecordingStateMachine();
+
+    const pending = createAttachedRecording(stateMachine);
+    stateMachine.dispatch({ type: 'STOP_RECORDING', id: pending.id });
+
+    const artifactAttached = stateMachine.dispatch({
+      type: 'ATTACH_RECORDING_ARTIFACT',
+      id: pending.id,
+      filepath: '/tmp/recording.opus',
+    });
+
+    expect(artifactAttached).toMatchObject({
+      sampleRate: 48000,
+      numberOfChannels: 2,
+    });
+  });
+
+  test.each([
+    { status: 'success' as const, errorMessage: undefined },
+    { status: 'failed' as const, errorMessage: 'native start failed' },
+  ])(
+    'settles recordings into ready state with blockCreationStatus=$status',
+    ({ status, errorMessage }) => {
+      const stateMachine = new RecordingStateMachine();
+
+      const pending = stateMachine.dispatch({
+        type: 'START_RECORDING',
+      });
+      expect(pending?.status).toBe('recording');
+
+      const settled = stateMachine.dispatch({
+        type: 'SET_BLOCK_CREATION_STATUS',
+        id: pending!.id,
+        status,
+        errorMessage,
+      });
+      expect(settled).toMatchObject({
+        status: 'ready',
+        blockCreationStatus: status,
+      });
+
+      const next = stateMachine.dispatch({
+        type: 'START_RECORDING',
+      });
+      expect(next?.id).toBeGreaterThan(pending!.id);
+      expect(next?.status).toBe('recording');
+      expect(next?.blockCreationStatus).toBeUndefined();
+    }
+  );
+});