Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix: recover interrupted mobile recording completion

Akshar Patel808f616f2f5c
diff --git a/apps/mobile/src/uploads/recording-upload-provider.test.tsx b/apps/mobile/src/uploads/recording-upload-provider.test.tsx
index 5150003d0..d6b070696 100644
--- a/apps/mobile/src/uploads/recording-upload-provider.test.tsx
+++ b/apps/mobile/src/uploads/recording-upload-provider.test.tsx
@@ -1,6 +1,6 @@
import type { ReactNode } from "react";
import TestRenderer, { act } from "react-test-renderer";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import {
RecordingUploadProvider,
useRecordingUploadActions,
@@ -8,6 +8,7 @@ import {
useRecordingUploadLibraryRevision,
useRecordingUploads,
} from "./recording-upload-provider";
+import type { RecordingUploadJob } from "./recording-upload-queue";
(
globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }
@@ -19,7 +20,7 @@ const fileSystemMock = vi.hoisted(() => ({
readAsStringAsync: vi.fn(
(): Promise<string> => Promise.reject(new Error("Not found")),
),
- writeAsStringAsync: vi.fn(() => Promise.resolve()),
+ writeAsStringAsync: vi.fn((_uri: string, _value: string) => Promise.resolve()),
}));
const uploadToTarget = vi.hoisted(() => vi.fn(() => Promise.resolve()));
@@ -30,6 +31,7 @@ const screenRecordingState = vi.hoisted(() => ({
}));
const authState = vi.hoisted(() => ({
+ status: "signedIn" as "loading" | "signedIn" | "signedOut",
createRecording: vi.fn(),
createRecordingUploadTargets: vi.fn(),
completeRecording: vi.fn(() => Promise.resolve({ success: true })),
@@ -52,7 +54,7 @@ vi.mock("../../modules/cap-screen-recorder", () => ({
}));
vi.mock("@/auth/AuthContext", () => ({
useAuth: () => ({
- status: "signedIn",
+ status: authState.status,
bootstrap: { activeOrganizationId: "org_123" },
client: authState,
refresh: authState.refresh,
@@ -93,7 +95,63 @@ const flushQueue = async () => {
}
};
+const uploadedRecording: RecordingUploadJob = {
+ id: "cap_123",
+ shareUrl: "https://cap.so/s/cap_123",
+ createdAt: "2026-07-23T08:00:00.000Z",
+ status: "processing",
+ durationSeconds: 2,
+ totalBytes: 626_000,
+ uploadedBytes: 626_000,
+ uploadOwner: "app",
+ serverPhase: null,
+ processingProgress: 0,
+ processingMessage: null,
+ error: null,
+ retryCount: 0,
+ segments: [
+ {
+ track: "video",
+ type: "initialization",
+ index: 0,
+ uri: "file:///recording/video_init.mp4",
+ durationSeconds: 0,
+ byteLength: 1_000,
+ uploaded: true,
+ },
+ {
+ track: "video",
+ type: "media",
+ index: 1,
+ uri: "file:///recording/video_segment_001.m4s",
+ durationSeconds: 2,
+ byteLength: 625_000,
+ uploaded: true,
+ },
+ ],
+};
+
describe("RecordingUploadProvider", () => {
+ let recoveryRenderer: ReturnType<typeof TestRenderer.create> | null = null;
+ const mountRecoveryProvider = async () => {
+ await act(async () => {
+ recoveryRenderer = TestRenderer.create(
+ <RecordingUploadProvider>
+ <Harness />
+ </RecordingUploadProvider>,
+ );
+ });
+ await flushQueue();
+ };
+
+ afterEach(async () => {
+ await act(async () => {
+ recoveryRenderer?.unmount();
+ recoveryRenderer = null;
+ });
+ vi.useRealTimers();
+ });
+
beforeEach(() => {
recordingUploads = null;
recordingUploadActions = null;
@@ -103,8 +161,10 @@ describe("RecordingUploadProvider", () => {
displayQueueRenderCount = 0;
libraryRevisionRenderCount = 0;
fileSystemMock.deleteAsync.mockClear();
- fileSystemMock.readAsStringAsync.mockClear();
- fileSystemMock.writeAsStringAsync.mockClear();
+ fileSystemMock.readAsStringAsync.mockReset();
+ fileSystemMock.readAsStringAsync.mockRejectedValue(new Error("Not found"));
+ fileSystemMock.writeAsStringAsync.mockReset();
+ fileSystemMock.writeAsStringAsync.mockResolvedValue(undefined);
uploadToTarget.mockClear();
screenRecordingState.cancel.mockClear();
screenRecordingState.getUpdates.mockReset();
@@ -129,7 +189,9 @@ describe("RecordingUploadProvider", () => {
),
}),
);
- authState.completeRecording.mockClear();
+ authState.status = "signedIn";
+ authState.completeRecording.mockReset();
+ authState.completeRecording.mockResolvedValue({ success: true });
authState.deleteCap.mockClear();
authState.getCapStatuses.mockReset();
authState.getCapStatuses.mockImplementation((ids: readonly string[]) =>
@@ -141,6 +203,227 @@ describe("RecordingUploadProvider", () => {
authState.updateUploadProgress.mockClear();
});
+ it.each([false, true])(
+ "resumes interrupted completion after restart when the server accepted it: %s",
+ async (acceptedBeforeRestart) => {
+ vi.useFakeTimers();
+ let persisted = "";
+ fileSystemMock.writeAsStringAsync.mockImplementation(
+ (_uri: string, value: string) => {
+ persisted = value;
+ return Promise.resolve();
+ },
+ );
+ let accepted = false;
+ authState.getCapStatuses.mockImplementation(async () => ({
+ caps: [
+ {
+ id: "cap_123",
+ upload: {
+ uploaded: 626_000,
+ total: 626_000,
+ phase: accepted ? "processing" : "uploading",
+ processingProgress: 0,
+ processingMessage: null,
+ processingError: null,
+ },
+ },
+ ],
+ }));
+ authState.completeRecording.mockImplementationOnce(() => {
+ accepted = acceptedBeforeRestart;
+ return new Promise<never>(() => {});
+ });
+ await mountRecoveryProvider();
+ await act(async () => {
+ await recordingUploads?.beginRecording({
+ fileName: "Cap Recording.mp4",
+ width: 720,
+ height: 1280,
+ fps: 30,
+ });
+ for (const segment of uploadedRecording.segments) {
+ recordingUploads?.addSegment("cap_123", segment);
+ }
+ recordingUploads?.finishRecording("cap_123", {
+ durationSeconds: 2,
+ totalBytes: 626_000,
+ });
+ });
+ await flushQueue();
+ expect(authState.completeRecording).toHaveBeenCalledTimes(1);
+ expect(uploadToTarget).toHaveBeenCalledTimes(2);
+ expect(fileSystemMock.deleteAsync).not.toHaveBeenCalled();
+ const persistedBeforeRestart = persisted;
+ const firstRequest = authState.completeRecording.mock.calls[0];
+ await act(async () => recoveryRenderer?.unmount());
+ fileSystemMock.readAsStringAsync.mockResolvedValueOnce(persisted);
+ authState.completeRecording.mockImplementation(async () => {
+ accepted = true;
+ return { success: true };
+ });
+ await mountRecoveryProvider();
+ expect(authState.completeRecording).toHaveBeenCalledTimes(2);
+ expect(authState.completeRecording.mock.calls[1]).toEqual(firstRequest);
+ expect(JSON.parse(persistedBeforeRestart)).toMatchObject({
+ jobs: [
+ {
+ status: "uploading",
+ serverPhase: null,
+ segments: [{ uploaded: true }, { uploaded: true }],
+ },
+ ],
+ });
+ expect(uploadToTarget).toHaveBeenCalledTimes(2);
+ expect(recordingUploads?.queue.jobs[0]?.status).toBe("processing");
+ expect(fileSystemMock.deleteAsync).toHaveBeenCalledWith(
+ "file:///recording",
+ { idempotent: true },
+ );
+ await act(async () => vi.advanceTimersByTimeAsync(30_000));
+ expect(authState.completeRecording).toHaveBeenCalledTimes(2);
+ authState.getCapStatuses.mockResolvedValue({
+ caps: [{ id: "cap_123", upload: null }],
+ });
+ await act(async () => vi.advanceTimersByTimeAsync(3000));
+ expect(recordingUploads?.queue.jobs[0]?.status).toBe("complete");
+ await act(async () => vi.advanceTimersByTimeAsync(4000));
+ expect(recordingUploads?.queue.jobs).toEqual([]);
+ },
+ );
+
+ it.each([null, "uploading"] as const)(
+ "recovers an already-stranded camera completion with persisted server phase %s once",
+ async (serverPhase) => {
+ vi.useFakeTimers();
+ fileSystemMock.readAsStringAsync.mockResolvedValueOnce(
+ JSON.stringify({
+ jobs: [
+ {
+ ...uploadedRecording,
+ status: serverPhase === null ? "processing" : "uploading",
+ serverPhase,
+ },
+ ],
+ }),
+ );
+ authState.getCapStatuses.mockResolvedValue({
+ caps: [
+ {
+ id: "cap_123",
+ upload: {
+ uploaded: 626_000,
+ total: 626_000,
+ phase: "uploading",
+ processingProgress: 0,
+ processingMessage: null,
+ processingError: null,
+ },
+ },
+ ],
+ });
+ await mountRecoveryProvider();
+ expect(authState.completeRecording).toHaveBeenCalledTimes(1);
+ expect(uploadToTarget).not.toHaveBeenCalled();
+ await act(async () => vi.advanceTimersByTimeAsync(30_000));
+ expect(authState.completeRecording).toHaveBeenCalledTimes(1);
+ },
+ );
+
+ it.each([
+ { uploadOwner: "external", serverPhase: null },
+ { serverPhase: "processing" },
+ { serverPhase: "generating_thumbnail" },
+ { status: "complete" },
+ { durationSeconds: null },
+ { segments: [] },
+ {
+ segments: uploadedRecording.segments.map((segment) => ({
+ ...segment,
+ uploaded: false,
+ })),
+ },
+ ] satisfies Partial<RecordingUploadJob>[])(
+ "preserves startup upload ownership and processing: %j",
+ async (overrides) => {
+ vi.useFakeTimers();
+ const job = { ...uploadedRecording, ...overrides };
+ authState.getCapStatuses.mockImplementation(
+ () => new Promise<never>(() => {}),
+ );
+ fileSystemMock.readAsStringAsync.mockResolvedValueOnce(
+ JSON.stringify({ jobs: [job] }),
+ );
+ screenRecordingState.getUpdates.mockResolvedValue({
+ status: "uploading",
+ durationSeconds: 2,
+ totalBytes: 626_000,
+ segments: [],
+ });
+ await mountRecoveryProvider();
+ expect(recordingUploads?.queue.jobs[0]).toMatchObject({
+ status: job.status,
+ serverPhase: job.serverPhase,
+ uploadOwner: job.uploadOwner,
+ });
+ expect(authState.completeRecording).not.toHaveBeenCalled();
+ expect(uploadToTarget).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each(["loading", "signedOut"] as const)(
+ "does not recover a camera completion while auth is %s",
+ async (status) => {
+ vi.useFakeTimers();
+ authState.status = status;
+ fileSystemMock.readAsStringAsync.mockResolvedValueOnce(
+ JSON.stringify({ jobs: [uploadedRecording] }),
+ );
+ await mountRecoveryProvider();
+ expect(authState.completeRecording).not.toHaveBeenCalled();
+ expect(uploadToTarget).not.toHaveBeenCalled();
+ if (status === "signedOut") {
+ expect(recordingUploads?.queue.jobs).toEqual([]);
+ return;
+ }
+ expect(recordingUploads?.queue.jobs[0]?.status).toBe("uploading");
+ authState.status = "signedIn";
+ await act(async () => {
+ recoveryRenderer?.update(
+ <RecordingUploadProvider>
+ <Harness />
+ </RecordingUploadProvider>,
+ );
+ });
+ await flushQueue();
+ expect(authState.completeRecording).toHaveBeenCalledTimes(1);
+ },
+ );
+
+ it("does not restore a discarded recovery when completion responds late", async () => {
+ vi.useFakeTimers();
+ let acknowledge: (() => void) | undefined;
+ authState.completeRecording.mockImplementationOnce(
+ () =>
+ new Promise((resolve) => {
+ acknowledge = () => resolve({ success: true });
+ }),
+ );
+ fileSystemMock.readAsStringAsync.mockResolvedValueOnce(
+ JSON.stringify({ jobs: [uploadedRecording] }),
+ );
+ await mountRecoveryProvider();
+ expect(authState.completeRecording).toHaveBeenCalledTimes(1);
+ expect(fileSystemMock.deleteAsync).not.toHaveBeenCalled();
+ await act(async () => recordingUploads?.discardRecording("cap_123"));
+ expect(authState.deleteCap).toHaveBeenCalledWith("cap_123");
+ await act(async () => acknowledge?.());
+ await flushQueue();
+ await act(async () => vi.advanceTimersByTimeAsync(30_000));
+ expect(recordingUploads?.queue.jobs).toEqual([]);
+ expect(authState.completeRecording).toHaveBeenCalledTimes(1);
+ });
+
it("keeps high-frequency segment progress out of unrelated subscriptions", async () => {
await act(async () => {
TestRenderer.create(
diff --git a/apps/mobile/src/uploads/recording-upload-provider.tsx b/apps/mobile/src/uploads/recording-upload-provider.tsx
index a2f10f569..35184e2f8 100644
--- a/apps/mobile/src/uploads/recording-upload-provider.tsx
+++ b/apps/mobile/src/uploads/recording-upload-provider.tsx
@@ -652,7 +652,7 @@ export function RecordingUploadProvider({ children }: { children: ReactNode }) {
);
}
- apply({ type: "processing", id: job.id });
+ flushPersist();
await authClient.completeRecording(job.id, {
durationSeconds: job.durationSeconds,
totalBytes: job.totalBytes,
@@ -665,6 +665,7 @@ export function RecordingUploadProvider({ children }: { children: ReactNode }) {
duration: segment.durationSeconds,
})),
});
+ apply({ type: "processing", id: job.id });
notifyLibraryChanged();
await refreshAuth().catch(() => undefined);
const directory = recordingDirectoryFromSegment(job.segments[0]);
diff --git a/apps/mobile/src/uploads/recording-upload-queue.ts b/apps/mobile/src/uploads/recording-upload-queue.ts
index 135f1b6a5..6c12a183f 100644
--- a/apps/mobile/src/uploads/recording-upload-queue.ts
+++ b/apps/mobile/src/uploads/recording-upload-queue.ts
@@ -385,18 +385,26 @@ const parseJob = (value: unknown): RecordingUploadJob | null => {
serverPhase !== null && typeof value.uploadedBytes === "number"
? Math.min(value.totalBytes, Math.max(0, value.uploadedBytes))
: segmentUploadedBytes;
+ const resumeCompletion =
+ uploadOwner === "app" &&
+ storedDuration !== null &&
+ status !== "complete" &&
+ (status === "processing" || serverPhase === "uploading") &&
+ (serverPhase === null || serverPhase === "uploading") &&
+ parsedSegments.length > 0 &&
+ parsedSegments.every((segment) => segment.uploaded);
return {
id: value.id,
shareUrl: value.shareUrl,
createdAt: value.createdAt,
- status,
+ status: resumeCompletion ? "uploading" : status,
durationSeconds,
totalBytes: value.totalBytes,
uploadedBytes,
segments: parsedSegments,
uploadOwner,
- serverPhase,
+ serverPhase: resumeCompletion ? null : serverPhase,
processingProgress:
typeof value.processingProgress === "number"
? Math.min(100, Math.max(0, value.processingProgress))