mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
214 lines
8.3 KiB
TypeScript
214 lines
8.3 KiB
TypeScript
import { Utils } from "@nativescript/core";
|
|
import { ignoredMediaPackages, isMediaAppEnabled, MEDIA_APPS_KEY, rememberMediaApps } from "./media-apps";
|
|
import { onSettingsStoreChanged } from "./settings-store";
|
|
import { parseMediaBrowseItems, type MediaBrowseItem, type MediaBrowserApp, type MediaBrowserBridge } from "./media-types";
|
|
import { spotifyService } from "./spotify";
|
|
import type { SpotifyLibrary } from "./spotify-library";
|
|
import { SPOTIFY_ANDROID_PACKAGE } from "./spotify-player";
|
|
|
|
declare const com: any;
|
|
|
|
export type { MediaBrowseItem, MediaBrowserApp } from "./media-types";
|
|
|
|
type PendingRequest<T> = {
|
|
resolve: (value: T) => void;
|
|
reject: (error: Error) => void;
|
|
};
|
|
|
|
/**
|
|
* Bridge to FaceclawMediaBrowser: connects to other apps' media browser
|
|
* services (the mechanism Android Auto uses) to browse their libraries and
|
|
* start playback, including starting a player that is not currently running.
|
|
* Holds at most one connection at a time.
|
|
*/
|
|
export class FaceclawMediaBrowserBridge implements MediaBrowserBridge {
|
|
private browser: any = null;
|
|
private listenerProxy: any = null;
|
|
private nextRequestId = 1;
|
|
private readonly pendingConnects = new Map<number, PendingRequest<string>>();
|
|
private readonly pendingBrowses = new Map<number, PendingRequest<MediaBrowseItem[]>>();
|
|
private appsCache: MediaBrowserApp[] | null = null;
|
|
private connectedPackage = "";
|
|
|
|
/** Installed apps exposing a media browser service; cached after the first call. */
|
|
listBrowsableApps(refresh = false): MediaBrowserApp[] {
|
|
if (!global.isAndroid) return [];
|
|
if (this.appsCache && !refresh) return this.enabledApps();
|
|
this.ensureBrowser();
|
|
if (!this.browser) return [];
|
|
try {
|
|
const raw = JSON.parse(String(this.browser.listBrowsableAppsJson())) as Array<{
|
|
packageName?: string;
|
|
serviceClass?: string;
|
|
appName?: string;
|
|
}>;
|
|
this.appsCache = raw.map((app) => ({
|
|
packageName: String(app.packageName ?? ""),
|
|
serviceClass: String(app.serviceClass ?? ""),
|
|
appName: String(app.appName ?? ""),
|
|
}));
|
|
rememberMediaApps(this.appsCache);
|
|
} catch (error) {
|
|
console.warn(`media browser app list parse failed: ${error}`);
|
|
this.appsCache = [];
|
|
}
|
|
return this.enabledApps();
|
|
}
|
|
|
|
private enabledApps(): MediaBrowserApp[] {
|
|
const ignored = new Set(ignoredMediaPackages());
|
|
return (this.appsCache ?? []).filter((app) => !ignored.has(app.packageName));
|
|
}
|
|
|
|
/**
|
|
* Connect to an app's browser service, starting its process if needed;
|
|
* replaces any existing connection. Resolves to the browse-tree root id.
|
|
*/
|
|
connect(app: MediaBrowserApp): Promise<string> {
|
|
if (!global.isAndroid) return Promise.reject(new Error("Android only"));
|
|
if (!isMediaAppEnabled(app.packageName)) return Promise.reject(new Error("App is ignored in Music settings"));
|
|
this.ensureBrowser();
|
|
if (!this.browser) return Promise.reject(new Error("Media browser unavailable"));
|
|
const requestId = this.nextRequestId++;
|
|
this.connectedPackage = app.packageName;
|
|
return new Promise<string>((resolve, reject) => {
|
|
this.pendingConnects.set(requestId, { resolve, reject });
|
|
this.browser.connect(requestId, app.packageName, app.serviceClass);
|
|
});
|
|
}
|
|
|
|
/** Fetch one level of the connected service's content tree. */
|
|
browse(parentId: string): Promise<MediaBrowseItem[]> {
|
|
if (!global.isAndroid) return Promise.reject(new Error("Android only"));
|
|
if (this.connectedPackage && !isMediaAppEnabled(this.connectedPackage)) {
|
|
this.disconnect();
|
|
return Promise.reject(new Error("App is ignored in Music settings"));
|
|
}
|
|
this.ensureBrowser();
|
|
if (!this.browser) return Promise.reject(new Error("Media browser unavailable"));
|
|
const requestId = this.nextRequestId++;
|
|
return new Promise<MediaBrowseItem[]>((resolve, reject) => {
|
|
this.pendingBrowses.set(requestId, { resolve, reject });
|
|
this.browser.browse(requestId, parentId);
|
|
});
|
|
}
|
|
|
|
/** Start playback of a browsed item through the connected player's session. */
|
|
playFromMediaId(mediaId: string): void {
|
|
if (!global.isAndroid) return;
|
|
if (!this.connectedPackage || !isMediaAppEnabled(this.connectedPackage)) return;
|
|
this.browser?.playFromMediaId(mediaId);
|
|
}
|
|
|
|
/** Drop the connection; in-flight requests are rejected. */
|
|
disconnect(): void {
|
|
if (!global.isAndroid) return;
|
|
this.rejectAllPending("Disconnected");
|
|
this.connectedPackage = "";
|
|
this.browser?.disconnect();
|
|
}
|
|
|
|
private rejectAllPending(reason: string): void {
|
|
const pending = [...this.pendingConnects.values(), ...this.pendingBrowses.values()];
|
|
this.pendingConnects.clear();
|
|
this.pendingBrowses.clear();
|
|
for (const request of pending) {
|
|
request.reject(new Error(reason));
|
|
}
|
|
}
|
|
|
|
private ensureBrowser(): void {
|
|
if (!global.isAndroid || this.browser) return;
|
|
const context = Utils.android.getApplicationContext();
|
|
if (!context) {
|
|
throw new Error("Android application context unavailable");
|
|
}
|
|
this.browser = new com.faceclaw.app.FaceclawMediaBrowser(context);
|
|
onSettingsStoreChanged((key) => {
|
|
if (key === MEDIA_APPS_KEY && this.connectedPackage && !isMediaAppEnabled(this.connectedPackage)) {
|
|
this.disconnect();
|
|
}
|
|
});
|
|
this.listenerProxy = new com.faceclaw.app.FaceclawMediaBrowserListener({
|
|
onConnectResult: (requestId: number, connected: boolean, rootId: string, error: string) => {
|
|
const pending = this.pendingConnects.get(Number(requestId));
|
|
if (!pending) return;
|
|
this.pendingConnects.delete(Number(requestId));
|
|
if (connected) pending.resolve(String(rootId));
|
|
else pending.reject(new Error(String(error) || "Connection failed"));
|
|
},
|
|
onBrowseResult: (requestId: number, childrenJson: string, error: string) => {
|
|
const pending = this.pendingBrowses.get(Number(requestId));
|
|
if (!pending) return;
|
|
this.pendingBrowses.delete(Number(requestId));
|
|
const json = String(childrenJson ?? "");
|
|
if (!json) {
|
|
pending.reject(new Error(String(error) || "Browse failed"));
|
|
return;
|
|
}
|
|
try {
|
|
pending.resolve(parseMediaBrowseItems(json));
|
|
} catch (parseError) {
|
|
pending.reject(new Error(`Browse result parse failed: ${parseError}`));
|
|
}
|
|
},
|
|
onDisconnected: () => {
|
|
this.rejectAllPending("Connection lost");
|
|
},
|
|
});
|
|
this.browser.setListener(this.listenerProxy);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The Android libraries: apps' media browser services, with Spotify's
|
|
* library from its Web API instead. Spotify's own browser service admits
|
|
* only allowlisted callers (Android Auto, Wear, Assistant), so connecting to
|
|
* it always fails; signed in, its row opens the Web API library, and signed
|
|
* out, opening it says how to sign in. Signed in with Spotify not installed,
|
|
* the library is still offered (it plays on the user's other devices).
|
|
*/
|
|
export class AndroidMediaBrowserBridge implements MediaBrowserBridge {
|
|
private current: MediaBrowserBridge | null = null;
|
|
|
|
constructor(
|
|
private readonly services: MediaBrowserBridge,
|
|
private readonly spotify: () => SpotifyLibrary | null,
|
|
private readonly isEnabled: (packageName: string) => boolean = isMediaAppEnabled,
|
|
) {}
|
|
|
|
listBrowsableApps(refresh = false): MediaBrowserApp[] {
|
|
const apps = this.services.listBrowsableApps(refresh);
|
|
const library = this.spotify();
|
|
if (!library || apps.some((app) => app.packageName === SPOTIFY_ANDROID_PACKAGE) || !this.isEnabled(SPOTIFY_ANDROID_PACKAGE)) {
|
|
return apps;
|
|
}
|
|
return [...apps, ...library.listBrowsableApps()];
|
|
}
|
|
|
|
connect(app: MediaBrowserApp): Promise<string> {
|
|
this.disconnect();
|
|
const library = app.packageName === SPOTIFY_ANDROID_PACKAGE ? this.spotify() : null;
|
|
this.current = library ?? this.services;
|
|
return this.current.connect(library ? library.app : app);
|
|
}
|
|
|
|
browse(parentId: string): Promise<MediaBrowseItem[]> {
|
|
return this.current ? this.current.browse(parentId) : Promise.reject(new Error("Not connected"));
|
|
}
|
|
|
|
playFromMediaId(mediaId: string): void {
|
|
this.current?.playFromMediaId(mediaId);
|
|
}
|
|
|
|
disconnect(): void {
|
|
this.current?.disconnect();
|
|
this.current = null;
|
|
}
|
|
}
|
|
|
|
export const mediaBrowserBridge: MediaBrowserBridge = new AndroidMediaBrowserBridge(
|
|
new FaceclawMediaBrowserBridge(),
|
|
() => spotifyService()?.library ?? null,
|
|
);
|