fix(lifecycle): defer mobile podcast view startup

Author: chhoumann

src/getContextMenuHandler.ts

@@ -7,6 +7,7 @@ import {
 	playedEpisodes,
 	currentEpisode,
 	viewState,
+	plugin,
 } from "./store";
 import type { LocalEpisode } from "./types/LocalEpisode";
 import { ViewState } from "./types/ViewState";
@@ -75,6 +76,7 @@ export default function getContextMenuHandler(app: App): EventRef {
 
 						currentEpisode.set(localEpisode);
 						viewState.set(ViewState.Player);
+						get(plugin)?.enablePodcastViewMount();
 
 						// Setting the stores above only updates an already-mounted
 						// PodNotes view. When the view is closed (or hidden in a

src/main.activateView.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import PodNotes from "./main";
 import { VIEW_TYPE } from "./constants";
+import { Platform } from "obsidian";
 
 // Regression coverage for #55: "Show PodNotes" / the ribbon icon must reliably
 // surface the view. The bug was that the command was gated on the leaf NOT
@@ -14,6 +15,13 @@ function makeLeaf() {
 	};
 }
 
+const originalPlatform = { ...Platform };
+
+afterEach(() => {
+	Object.assign(Platform, originalPlatform);
+	vi.useRealTimers();
+});
+
 function setupPlugin({
 	existingLeaves = [] as ReturnType<typeof makeLeaf>[],
 	rightLeaf = makeLeaf() as ReturnType<typeof makeLeaf> | null,
@@ -27,6 +35,10 @@ function setupPlugin({
 	// Build a bare instance so we exercise activateView without running the full
 	// onload() side effects (store wiring, command registration, etc.).
 	const plugin = Object.create(PodNotes.prototype) as PodNotes;
+	Object.assign(plugin as unknown as Record<string, unknown>, {
+		podcastViewMountEnabled: true,
+		views: new Set(),
+	});
 	(plugin as unknown as { app: { workspace: typeof workspace } }).app = {
 		workspace,
 	};
@@ -70,6 +82,100 @@ describe("PodNotes.activateView", () => {
 		await expect(plugin.activateView()).resolves.toBeUndefined();
 		expect(workspace.revealLeaf).not.toHaveBeenCalled();
 	});
+
+	it("enables and mounts a dormant restored view before revealing it", async () => {
+		const existing = makeLeaf();
+		const firstRestoredView = { mountPodcastView: vi.fn() };
+		const secondRestoredView = { mountPodcastView: vi.fn() };
+		const { plugin } = setupPlugin({ existingLeaves: [existing] });
+		Object.assign(plugin as unknown as Record<string, unknown>, {
+			podcastViewMountEnabled: false,
+			views: new Set([firstRestoredView, secondRestoredView]),
+		});
+
+		expect(plugin.shouldMountPodcastView()).toBe(false);
+
+		await plugin.activateView();
+
+		expect(plugin.shouldMountPodcastView()).toBe(true);
+		expect(firstRestoredView.mountPodcastView).toHaveBeenCalledTimes(1);
+		expect(secondRestoredView.mountPodcastView).toHaveBeenCalledTimes(1);
+	});
+});
+
+describe("PodNotes.onLayoutReady", () => {
+	function setupLayoutPlugin({
+		existingLeaves = [] as ReturnType<typeof makeLeaf>[],
+		layoutReady = true,
+		rightLeaf = makeLeaf() as ReturnType<typeof makeLeaf> | null,
+	} = {}) {
+		const workspace = {
+			layoutReady,
+			getLeavesOfType: vi.fn().mockReturnValue(existingLeaves),
+			getRightLeaf: vi.fn().mockReturnValue(rightLeaf),
+			detachLeavesOfType: vi.fn(),
+		};
+
+		const plugin = Object.create(PodNotes.prototype) as PodNotes;
+		Object.assign(plugin as unknown as Record<string, unknown>, {
+			isUnloaded: false,
+			layoutReadyAttempts: 0,
+			layoutReadyRetry: null,
+			maxLayoutReadyAttempts: 10,
+			views: new Set(),
+		});
+		(plugin as unknown as { app: { workspace: typeof workspace } }).app = {
+			workspace,
+		};
+
+		return { plugin, workspace, rightLeaf };
+	}
+
+	it("creates the startup view on desktop when no leaf exists", () => {
+		const { plugin, workspace, rightLeaf } = setupLayoutPlugin();
+
+		plugin.onLayoutReady();
+
+		expect(workspace.getRightLeaf).toHaveBeenCalledWith(false);
+		expect(rightLeaf?.setViewState).toHaveBeenCalledWith({
+			type: VIEW_TYPE,
+		});
+	});
+
+	it("does not auto-create the startup view in the mobile app", () => {
+		Object.assign(Platform, {
+			isDesktop: false,
+			isDesktopApp: false,
+			isIosApp: true,
+			isMobile: true,
+			isMobileApp: true,
+			isPhone: true,
+		});
+		const { plugin, workspace, rightLeaf } = setupLayoutPlugin();
+
+		plugin.onLayoutReady();
+
+		expect(workspace.getLeavesOfType).not.toHaveBeenCalled();
+		expect(workspace.getRightLeaf).not.toHaveBeenCalled();
+		expect(rightLeaf?.setViewState).not.toHaveBeenCalled();
+		expect(workspace.detachLeavesOfType).not.toHaveBeenCalled();
+	});
+
+	it("cancels a pending startup retry on unload", () => {
+		vi.useFakeTimers();
+		const { plugin, workspace } = setupLayoutPlugin({ layoutReady: false });
+
+		plugin.onLayoutReady();
+		expect(vi.getTimerCount()).toBe(1);
+
+		plugin.onunload();
+		expect(vi.getTimerCount()).toBe(0);
+
+		vi.advanceTimersByTime(100);
+
+		expect(workspace.getRightLeaf).not.toHaveBeenCalled();
+		expect(workspace.detachLeavesOfType).toHaveBeenCalledWith(VIEW_TYPE);
+	});
 });
 
 // Locks the actual #55 wiring (not just activateView's internals): the
@@ -123,6 +229,7 @@ describe("PodNotes onload wiring (#55)", () => {
 			registerView: vi.fn(),
 			registerObsidianProtocolHandler: vi.fn(),
 			registerEvent: vi.fn(),
+			views: new Set(),
 			app: {
 				workspace: {
 					onLayoutReady: vi.fn(),

src/main.ts

@@ -12,7 +12,13 @@ import {
 	sanitizeEpisodeListLimit,
 	volume,
 } from "src/store";
-import { Notice, Plugin, type Editor, type WorkspaceLeaf } from "obsidian";
+import {
+	Notice,
+	Platform,
+	Plugin,
+	type Editor,
+	type WorkspaceLeaf,
+} from "obsidian";
 import { API } from "src/API/API";
 import type { IAPI } from "src/API/IAPI";
 import { DEFAULT_SETTINGS, VIEW_TYPE } from "src/constants";
@@ -64,7 +70,7 @@ export default class PodNotes extends Plugin implements IPodNotes {
 	public settings!: IPodNotesSettings;
 	public override app!: PartialAppExtension;
 
-	private view: MainView | null = null;
+	private views = new Set<MainView>();
 
 	private playedEpisodeController?: StoreController<{
 		[episodeName: string]: PlayedEpisode;
@@ -89,12 +95,17 @@ export default class PodNotes extends Plugin implements IPodNotes {
 
 	private maxLayoutReadyAttempts = 10;
 	private layoutReadyAttempts = 0;
+	private layoutReadyRetry: ReturnType<typeof setTimeout> | null = null;
+	private isUnloaded = false;
+	private podcastViewMountEnabled = !Platform.isMobileApp;
 	private isReady = false;
 	private pendingSave: IPodNotesSettings | null = null;
 	private saveScheduled = false;
 	private saveChain: Promise<void> = Promise.resolve();
 
 	override async onload() {
+		this.isUnloaded = false;
+		this.podcastViewMountEnabled = !Platform.isMobileApp;
 		plugin.set(this);
 
 		await this.loadSettings();
@@ -446,8 +457,9 @@ export default class PodNotes extends Plugin implements IPodNotes {
 		this.addSettingTab(new PodNotesSettingsTab(this.app, this));
 
 		this.registerView(VIEW_TYPE, (leaf: WorkspaceLeaf) => {
-			this.view = new MainView(leaf, this);
-			return this.view;
+			const view = new MainView(leaf, this);
+			this.views.add(view);
+			return view;
 		});
 
 		// Persistent, discoverable entry point in the left ribbon. The right
@@ -460,39 +472,62 @@ export default class PodNotes extends Plugin implements IPodNotes {
 
 		this.app.workspace.onLayoutReady(this.onLayoutReady.bind(this));
 
-		this.registerObsidianProtocolHandler("podnotes", (action) =>
-			podNotesURIHandler(action, this.api),
-		);
+		this.registerObsidianProtocolHandler("podnotes", (action) => {
+			this.enablePodcastViewMount();
+			return podNotesURIHandler(action, this.api);
+		});
 
 		this.registerEvent(getContextMenuHandler(this.app));
 
 		this.isReady = true;
 	}
 
 	onLayoutReady(): void {
+		if (this.isUnloaded) {
+			return;
+		}
+
+		if (Platform.isMobileApp) {
+			// Mobile startup is sensitive to creating plugin-owned side panes; keep
+			// PodNotes dormant until the user opens it with the command or ribbon.
+			this.clearLayoutReadyRetry();
+			this.layoutReadyAttempts = 0;
+			return;
+		}
+
 		if (!this.app.workspace || !this.app.workspace.layoutReady) {
 			// Workspace is not ready, schedule a retry
 			this.layoutReadyAttempts++;
-			if (this.layoutReadyAttempts < this.maxLayoutReadyAttempts) {
-				setTimeout(() => this.onLayoutReady(), 100);
-			} else {
+			if (this.layoutReadyAttempts >= this.maxLayoutReadyAttempts) {
 				console.error(
 					"Failed to initialize PodNotes layout after maximum attempts",
 				);
+			} else if (!this.layoutReadyRetry) {
+				this.layoutReadyRetry = setTimeout(() => {
+					this.layoutReadyRetry = null;
+					this.onLayoutReady();
+				}, 100);
 			}
 			return;
 		}
 
+		this.clearLayoutReadyRetry();
+		this.layoutReadyAttempts = 0;
+
 		if (this.app.workspace.getLeavesOfType(VIEW_TYPE).length) {
 			return;
 		}
 
 		const leaf = this.app.workspace.getRightLeaf(false);
 
 		if (leaf) {
-			leaf.setViewState({
-				type: VIEW_TYPE,
-			});
+			void leaf
+				.setViewState({
+					type: VIEW_TYPE,
+				})
+				.catch((error) => {
+					console.error("PodNotes: failed to initialize startup view", error);
+				});
 		}
 	}
 
@@ -501,6 +536,8 @@ export default class PodNotes extends Plugin implements IPodNotes {
 	// makes "Show PodNotes" and the ribbon icon reliably surface the view even
 	// when it is already open but hidden in a collapsed/overflowing sidebar (#55).
 	async activateView(): Promise<void> {
+		this.enablePodcastViewMount();
+
 		const { workspace } = this.app;
 
 		const existing = workspace.getLeavesOfType(VIEW_TYPE);
@@ -516,6 +553,21 @@ export default class PodNotes extends Plugin implements IPodNotes {
 		}
 	}
 
+	shouldMountPodcastView(): boolean {
+		return this.podcastViewMountEnabled;
+	}
+
+	enablePodcastViewMount(): void {
+		this.podcastViewMountEnabled = true;
+		for (const view of this.views) {
+			view.mountPodcastView();
+		}
+	}
+
+	unregisterPodcastView(view: MainView): void {
+		this.views.delete(view);
+	}
+
 	private getTranscriptionService(): TranscriptionService {
 		if (!this.transcriptionService) {
 			this.transcriptionService = new TranscriptionService(this);
@@ -525,6 +577,8 @@ export default class PodNotes extends Plugin implements IPodNotes {
 	}
 
 	override onunload() {
+		this.isUnloaded = true;
+		this.clearLayoutReadyRetry();
 		this.playedEpisodeController?.off();
 		this.savedFeedsController?.off();
 		this.playlistController?.off();
@@ -536,11 +590,19 @@ export default class PodNotes extends Plugin implements IPodNotes {
 		this.hidePlayedEpisodesController?.off();
 		this.volumeUnsubscribe?.();
 		this.localFilesMirrorUnsubscribe?.();
+		this.views.clear();
 
 		// Detach all leaves of this view type to prevent duplicates on reload
 		this.app.workspace.detachLeavesOfType(VIEW_TYPE);
 	}
 
+	private clearLayoutReadyRetry(): void {
+		if (!this.layoutReadyRetry) return;
+
+		clearTimeout(this.layoutReadyRetry);
+		this.layoutReadyRetry = null;
+	}
+
 	async loadSettings() {
 		const loadedData = await this.loadData();
 

src/types/IPodNotes.ts

@@ -1,9 +1,14 @@
-import type { IAPI } from 'src/API/IAPI';
-import type { IPodNotesSettings } from './IPodNotesSettings';
+import type { IAPI } from "src/API/IAPI";
+import type { IPodNotesSettings } from "./IPodNotesSettings";
 
+export interface PodNotesViewRegistration {
+	mountPodcastView(): void;
+}
 
 export interface IPodNotes {
 	settings: IPodNotesSettings;
 	api: IAPI;
+	shouldMountPodcastView(): boolean;
+	unregisterPodcastView(view: PodNotesViewRegistration): void;
 	saveSettings(): Promise<void>;
 }