chore: 2.0.25

Author: triniwiz

packages/audio-context/common.ts

@@ -469,158 +469,43 @@ export interface MediaElementLike extends MediaElementTapProvider {
 	[k: string]: any;
 }
 
-const PLAYER_REF_ = Symbol('[[playerRef]]');
+const usedMediaElements: WeakSet<MediaElementLike> = new WeakSet();
 
-export abstract class MediaElementAudioSourceBase {
-	protected [context_]: BaseAudioContext;
-	protected [PLAYER_REF_]: MediaElementLike;
-	protected _internalGain: any = null;
-	protected _activeSource: any = null;
-	protected _decoded: any = null;
-	protected _decodingFor: string | null = null;
-	protected _wasMuted = false;
-	protected _originalVolume = 1;
-	protected _onPlayBound: () => void;
-	protected _onPauseBound: () => void;
-	protected _onEndedBound: () => void;
-	protected _tapNode: any = null;
-	protected _usingTap = false;
-
-	constructor(context: BaseAudioContext, mediaElement: MediaElementLike) {
-		if (!(context instanceof BaseAudioContext)) throw new TypeError('MediaElementAudioSourceNode: invalid context');
-		if (!mediaElement || (typeof mediaElement.play !== 'function' && typeof mediaElement.src !== 'string')) {
-			throw new TypeError('MediaElementAudioSourceNode: requires a media element with `src` and `play()`');
-		}
-		this[context_] = context;
-		this[PLAYER_REF_] = mediaElement;
-		this._internalGain = this._createGainNode();
-
-		if (typeof mediaElement.attachAudioContextTap === 'function') {
-			try {
-				const tapNative = mediaElement.attachAudioContextTap((this.context as any).native);
-				if (tapNative) {
-					this._tapNode = this._wrapTapNative(tapNative);
-					if (this._tapNode) {
-						this._tapNode.connect(this._internalGain);
-						this._usingTap = true;
-					}
-				}
-			} catch (e) {}
-		}
-
-		this._onPlayBound = () => this._handlePlay();
-		this._onPauseBound = () => this._handlePause();
-		this._onEndedBound = () => this._handleEnded();
-		mediaElement.addEventListener?.('play', this._onPlayBound);
-		mediaElement.addEventListener?.('pause', this._onPauseBound);
-		mediaElement.addEventListener?.('ended', this._onEndedBound);
-	}
-	protected abstract _wrapTapNative(tapNative: any): { connect(t: any): void; disconnect(t?: any): void; stop?(): void } | null;
+export function resolveNativePlayer(mediaElement: MediaElementLike): any {
+	const m = mediaElement as any;
+	return m?.helper?.player ?? m?.player ?? m?._player ?? null;
+}
 
-	get mediaElement(): MediaElementLike {
-		return this[PLAYER_REF_];
+export function assertMediaElementUsable(context: BaseAudioContext, mediaElement: MediaElementLike): void {
+	if (!(context instanceof BaseAudioContext)) {
+		throw new TypeError('MediaElementAudioSourceNode: invalid context');
 	}
-
-	get context(): BaseAudioContext {
-		return this[context_];
+	if (!mediaElement || (typeof mediaElement.play !== 'function' && typeof mediaElement.src !== 'string')) {
+		throw new TypeError('MediaElementAudioSourceNode: requires a media element with `src` and `play()`');
 	}
-
-	get _outputNode() {
-		return this._internalGain;
+	if (usedMediaElements.has(mediaElement)) {
+		if (typeof DOMException !== 'undefined') {
+			throw new DOMException('The media element has already been connected to an AudioContext', 'InvalidStateError');
+		}
+		throw new Error('The media element has already been connected to an AudioContext');
 	}
+}
 
-	connect(target: any, output?: number, input?: number) {
-		return this._internalGain.connect(target, output, input);
-	}
-	disconnect(target?: any, output?: number, input?: number) {
-		return this._internalGain.disconnect(target, output, input);
-	}
+export function markMediaElementUsed(mediaElement: MediaElementLike): void {
+	try {
+		usedMediaElements.add(mediaElement);
+	} catch (e) {}
+}
 
-	disposeMediaElementSource() {
-		const el = this[PLAYER_REF_];
-		try {
-			el.removeEventListener?.('play', this._onPlayBound);
-			el.removeEventListener?.('pause', this._onPauseBound);
-			el.removeEventListener?.('ended', this._onEndedBound);
-		} catch (e) {}
-		if (this._usingTap) {
-			try {
-				el.detachAudioContextTap?.();
-			} catch (e) {}
-			try {
-				this._tapNode?.disconnect?.();
-			} catch (e) {}
-			this._tapNode = null;
-			this._usingTap = false;
-		}
-		this._stopActive();
-		this._restoreVolume();
-	}
-
-	protected abstract _createGainNode(): any;
-	protected abstract _createBufferSource(buffer: any): any;
-	protected abstract _decodeFromUrl(src: string): Promise<any>;
-
-	protected async _handlePlay() {
-		if (this._usingTap) return;
-		const el = this[PLAYER_REF_];
-		const src = el.src ?? '';
-		if (!src) return;
-		try {
-			if (this._decoded == null || this._decodingFor !== src) {
-				this._decodingFor = src;
-				this._decoded = await this._decodeFromUrl(src);
-			}
-			this._muteOriginal();
-			this._stopActive();
-			const source = this._createBufferSource(this._decoded);
-			source.loop = !!el.loop;
-			source.connect(this._internalGain);
-			source.start();
-			this._activeSource = source;
-		} catch (e) {}
-	}
-
-	protected _handlePause() {
-		if (this._usingTap) return;
-		this._stopActive();
-		this._restoreVolume();
-	}
-
-	protected _handleEnded() {
-		if (this._usingTap) return;
-		this._stopActive();
-		this._restoreVolume();
-	}
-
-	protected _stopActive() {
-		const s = this._activeSource;
-		this._activeSource = null;
-		if (!s) return;
-		try {
-			s.stop?.();
-			s.disconnect?.();
-		} catch (e) {}
-	}
-
-	protected _muteOriginal() {
-		if (this._wasMuted) return;
-		const el = this[PLAYER_REF_];
-		if (typeof el.volume === 'number') {
-			this._originalVolume = el.volume;
-			try {
-				el.volume = 0;
-				this._wasMuted = true;
-			} catch (e) {}
-		}
-	}
+export function unmarkMediaElementUsed(mediaElement: MediaElementLike): void {
+	try {
+		usedMediaElements.delete(mediaElement);
+	} catch (e) {}
+}
 
-	protected _restoreVolume() {
-		if (!this._wasMuted) return;
-		const el = this[PLAYER_REF_];
-		try {
-			el.volume = this._originalVolume;
-		} catch (e) {}
-		this._wasMuted = false;
+export function throwInvalidMediaElement(): never {
+	if (typeof DOMException !== 'undefined') {
+		throw new DOMException('Failed to attach a native source for the media element', 'InvalidStateError');
 	}
+	throw new Error('Failed to attach a native source for the media element');
 }

packages/audio-context/index.android.ts

@@ -1,5 +1,41 @@
 import { Utils } from '@nativescript/core';
-import { AnalyserOptions, AudioContextOptions, AudioNodeBase, AudioParamBase, AudioParamHooks, BaseAudioContext, ConstantSourceOptions, ConvolverOptions, DelayOptions, distanceModelFromNumber, distanceModelToNumber, DistanceModelType, IIRFilterOptions, MediaElementAudioSourceBase, MediaElementLike, panningModelFromNumber, panningModelToNumber, PanningModelType, PannerOptions, PeriodicWaveOptions, StereoPannerOptions, WaveShaperOptions, context_, looksLikePath, native_, nativeCtor_, normalizeSourcePath, resolveLatencyHint, resolvePannerOptions, AudioListenerBase } from './common';
+import {
+	AnalyserOptions,
+	AudioContextOptions,
+	AudioNodeBase,
+	AudioParamBase,
+	AudioParamHooks,
+	BaseAudioContext,
+	ConstantSourceOptions,
+	ConvolverOptions,
+	DelayOptions,
+	distanceModelFromNumber,
+	distanceModelToNumber,
+	DistanceModelType,
+	IIRFilterOptions,
+	MediaElementLike,
+	panningModelFromNumber,
+	panningModelToNumber,
+	PanningModelType,
+	PannerOptions,
+	PeriodicWaveOptions,
+	StereoPannerOptions,
+	WaveShaperOptions,
+	context_,
+	looksLikePath,
+	native_,
+	nativeCtor_,
+	normalizeSourcePath,
+	resolveLatencyHint,
+	resolvePannerOptions,
+	AudioListenerBase,
+	makeStubParamHooks,
+	assertMediaElementUsable,
+	markMediaElementUsed,
+	unmarkMediaElementUsed,
+	resolveNativePlayer,
+	throwInvalidMediaElement,
+} from './common';
 
 type NativeBaseAudioContext = BaseAudioContext & { native: org.nativescript.audiocontext.AudioContextInstance };
 
@@ -403,42 +439,83 @@ export class AudioBufferSourceNode extends AudioScheduledSourceNode {
 	set buffer(v: AudioBuffer | null) {
 		this.native.setBuffer(v?.native ?? (null as never));
 	}
-	protected _scheduledDuration(): number {
-		const b = this.native.getBuffer();
-		if (!b || this.native.getLoop()) return 0;
-		try {
-			return b.getDuration() || 0;
-		} catch (e) {
-			return 0;
-		}
-	}
 }
 
-export class MediaElementAudioSourceNode extends MediaElementAudioSourceBase {
-	constructor(context: AudioContext, mediaElement: MediaElementLike) {
-		super(context, mediaElement);
+export class MediaElementAudioSourceNode extends AudioNode {
+	private [native_]: org.nativescript.audiocontext.ExternalPcmSourceNode;
+	private _mediaElement: MediaElementLike;
+	private _playbackRateParam: AudioParam | null = null;
+
+	constructor(context: AudioContext, mediaElement: MediaElementLike, preExistingNative?: org.nativescript.audiocontext.ExternalPcmSourceNode) {
+		super(context as unknown as NativeBaseAudioContext);
+		assertMediaElementUsable(context, mediaElement);
+
+		const native = preExistingNative ?? MediaElementAudioSourceNode._createNative(context, mediaElement);
+		if (!native) throwInvalidMediaElement();
+
+		this._mediaElement = mediaElement;
+		this[native_] = native;
+		markMediaElementUsed(mediaElement);
+	}
+
+	private static _createNative(context: AudioContext, mediaElement: MediaElementLike): org.nativescript.audiocontext.ExternalPcmSourceNode | null {
+		const ctxNative: any = context.native;
+		if (!ctxNative) return null;
+		const player = resolveNativePlayer(mediaElement);
+		if (player && typeof ctxNative.createSourceNodeFromMediaPlayer === 'function') {
+			try {
+				const node = ctxNative.createSourceNodeFromMediaPlayer(player);
+				if (node) return node;
+			} catch (e) {}
+		}
+		if (typeof mediaElement.attachAudioContextTap === 'function') {
+			try {
+				const node = mediaElement.attachAudioContextTap(ctxNative);
+				if (node) return node;
+			} catch (e) {}
+		}
+		return null;
 	}
 
 	get context() {
 		return this[context_] as AudioContext;
 	}
 
-	protected _wrapTapNative(tapNative: any) {
-		if (!tapNative) return null;
-		const ctx = this.context;
-		const node = Object.create(AudioNode.prototype) as AudioNode & { native: org.nativescript.audiocontext.AudioNode };
-		(node as any)[context_] = ctx;
-		(node as any).native = tapNative;
-		return node;
+	get native() {
+		return this[native_];
 	}
-	protected _createGainNode() {
-		return this.context.createGain();
+
+	get mediaElement(): MediaElementLike {
+		return this._mediaElement;
 	}
-	protected _createBufferSource(buffer: AudioBuffer) {
-		return this.context.createBufferSource({ buffer });
+
+	get playbackRate(): AudioParam | null {
+		if (this._playbackRateParam) return this._playbackRateParam;
+		const native: any = this[native_];
+		try {
+			const param = typeof native?.getPlaybackRateParam === 'function' ? native.getPlaybackRateParam() : null;
+			if (param) {
+				this._playbackRateParam = new AudioParam(nativeCtor_, param);
+				return this._playbackRateParam;
+			}
+		} catch (e) {}
+		return null;
 	}
-	protected _decodeFromUrl(src: string): Promise<AudioBuffer> {
-		return this.context.decodeAudioData(src);
+
+	disposeMediaElementSource() {
+		const native = this[native_];
+		const el = this._mediaElement;
+		try {
+			const ctxNative: any = (this.context as any)?.native;
+			if (native && ctxNative && typeof ctxNative.detachSource === 'function') {
+				ctxNative.detachSource(native);
+			} else if (typeof el?.detachAudioContextTap === 'function') {
+				el.detachAudioContextTap();
+			}
+		} catch (e) {}
+		this._playbackRateParam = null;
+		this[native_] = null as never;
+		unmarkMediaElementUsed(el);
 	}
 }
 
@@ -607,6 +684,19 @@ export class AudioContext extends BaseAudioContext {
 		return new MediaElementAudioSourceNode(this, mediaElement);
 	}
 
+	createSourceNodeFromPlayer(playerNative: any): MediaElementAudioSourceNode | null {
+		try {
+			const native: any = this.native;
+			if (!native || !playerNative || typeof native.createSourceNodeFromMediaPlayer !== 'function') return null;
+			const tapNative = native.createSourceNodeFromMediaPlayer(playerNative);
+			if (!tapNative) return null;
+			const stub: MediaElementLike = { src: '', play() {}, pause() {} };
+			return new MediaElementAudioSourceNode(this, stub, tapNative);
+		} catch (e) {
+			return null;
+		}
+	}
+
 	get native() {
 		return this[native_];
 	}

packages/audio-context/index.d.ts

@@ -116,6 +116,7 @@ export class AudioScheduledSourceNode extends AudioNode {
 
 export declare class MediaElementAudioSourceNode extends AudioNode {
 	readonly mediaElement: MediaElementLike;
+	readonly playbackRate: AudioParam | null;
 	disposeMediaElementSource(): void;
 }
 
@@ -181,6 +182,7 @@ export declare class AudioBufferSourceNode extends AudioScheduledSourceNode {
 	constructor(context: BaseAudioContext, options: { buffer?: AudioBuffer });
 	loop: boolean;
 	buffer: AudioBuffer | null;
+	readonly playbackRate: AudioParam;
 }
 
 export declare class AudioContext extends BaseAudioContext {
@@ -204,6 +206,8 @@ export declare class AudioContext extends BaseAudioContext {
 	createPeriodicWave(real: Float32Array | number[], imag: Float32Array | number[], options?: { disableNormalization?: boolean }): PeriodicWave;
 	createMediaElementSource(mediaElement: MediaElementLike): MediaElementAudioSourceNode;
 
+	createSourceNodeFromPlayer(playerNative: any): AudioNode | null;
+
 	readonly state: AudioContextState;
 	onstatechange: ((ev: { type: 'statechange' }) => void) | null;
 	addEventListener(type: 'statechange', listener: (ev: { type: 'statechange' }) => void): void;