@amazon/vinyl 1.0.0

package/dist/types/current/streaming/SegmentControllerImpl.d.ts

@@ -0,0 +1,170 @@
+import { EventHostImpl, type ReadonlyAbort, type ReadonlyRanges } from '@amazon/vinyl-util';
+import type { ReadonlyPlaybackController } from '../playback/ReadonlyPlaybackController';
+import { type PrefetchOptions, type SegmentController, type SegmentControllerEventMap } from '../streaming/SegmentController';
+import type { SegmentReference } from '../streaming/SegmentReference';
+import type { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { MediaTimeline } from '../streaming/MediaTimeline';
+import type { QualitySelector } from '../streaming/abr/QualitySelector';
+/**
+ * The interval to check if additional segments should be prefetched.
+ */
+export declare const PREFETCH_POLL_THROTTLE = 1;
+export interface SegmentControllerImplDeps {
+    readonly playbackController: ReadonlyPlaybackController;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+    readonly qualitySelector: QualitySelector;
+}
+export interface SegmentControllerImplOptions {
+    /**
+     * The amount of time ahead of the playhead to prefetch when the track is active.
+     * Default: 240
+     */
+    readonly prefetchActive: number;
+    /**
+     * The amount of time to prefetch when the track is not active.
+     * Default: 20
+     */
+    readonly prefetchInactive: number;
+    /**
+     * The number of seconds behind the playhead to retain segments.
+     * Default: 30
+     */
+    readonly retainTail: number;
+}
+export declare const defaultSegmentControllerBaseOptions: SegmentControllerImplOptions;
+/**
+ * Default SegmentController implementation.
+ * Provides segments for a given time.
+ * Handles segment prefetching and caching.
+ *
+ * Uses mediaTimelineTransformed to resolve segments directly from the MediaTimeline.
+ */
+export declare class SegmentControllerImpl extends EventHostImpl<SegmentControllerEventMap> implements SegmentController {
+    readonly deps: SegmentControllerImplDeps;
+    readonly contentType: ContentType;
+    get [Symbol.toStringTag](): string;
+    private _active;
+    get active(): boolean;
+    private readonly _fetchedRanges;
+    private _startTime;
+    /**
+     * A map of decoder id to init segment slots.
+     * This allows representations with seamless bitstream switching to share initialization segments without
+     * making unnecessary requests or decoder re-initializations.
+     */
+    private readonly cachedInitSegments;
+    private readonly cachedSegments;
+    private readonly disposer;
+    readonly options: SegmentControllerImplOptions;
+    private prefetchingPriority;
+    /**
+     * True if the last segment in the prefetch range has been cached.
+     */
+    private ended;
+    private prefetching;
+    private _error;
+    private timeUpdateSub;
+    private seekingSub;
+    private readonly abort;
+    /**
+     * Cached last period lookup for fast repeated access.
+     */
+    private _cachedPeriod;
+    constructor(deps: SegmentControllerImplDeps, contentType: ContentType, options?: Partial<SegmentControllerImplOptions>);
+    get error(): Error | null;
+    getDuration(): Promise<number | null>;
+    /**
+     * Gets the period at the given time, using a cache for the last returned period.
+     */
+    private getPeriodAtTime;
+    /**
+     * Configures this segment provider and initiates prefetching.
+     * This may be called multiple times, for example when re-using a cached track a new track priority and start time
+     * can be provided.
+     */
+    configure(options: Partial<PrefetchOptions>): void;
+    get startTime(): number;
+    get trackPrefetchPriority(): number;
+    /**
+     * Returns the range that should be prefetched.
+     */
+    private get prefetchRange();
+    /**
+     * Returns the range that should be prefetched when inactive.
+     * This range will not be removed during sweeps unless `clear` is called.
+     */
+    private get prefetchRangeInactive();
+    /**
+     * Returns the range that should be prefetched while active.
+     */
+    private get prefetchRangeActive();
+    /**
+     * Clears data segments no longer within the current prefetch range.
+     * Init segments will not be changed.
+     */
+    private sweepCachedSegments;
+    /**
+     * Gets the next time to prefetch, or null if the prefetch range has been filled.
+     */
+    private getNextTimeToPrefetch;
+    private pollPrefetch;
+    private prefetchErrorHandler;
+    get fetchedRanges(): ReadonlyRanges;
+    /**
+     * Gets the number of seconds currently prefetched.
+     */
+    get fetchedTime(): number;
+    private _streamingQuality;
+    get streamingQuality(): MediaQualityMetadata | null;
+    private set streamingQuality(value);
+    getSegment(time: number, abort?: ReadonlyAbort): Promise<SegmentReference<ArrayBuffer> | null>;
+    private _getSegment;
+    /**
+     * Gets the minimum buffer time from the timeline.
+     * Falls back to a reasonable default.
+     */
+    private getMinBufferTime;
+    /**
+     * Prefetches the segment at the given time. Does not use the background scheduler.
+     *
+     * @param time
+     */
+    private prefetchImmediate;
+    /**
+     * Gets a streaming segment slot that spans the given time, or null if there is no media at that time.
+     * Slots will be cached until they slide out of the retention range or `clear` is called.
+     */
+    private getSlotAtTime;
+    /**
+     * Gets a cached init segment slot for the given decoder id. If a slot is not cached, create one.
+     */
+    private getOrCreateInitSlot;
+    /**
+     * Creates a slot that spans the given time, or returns null if there is no media at that time.
+     * Uses the mediaTimelineTransformed to resolve segments directly.
+     */
+    private createSlotForTime;
+    /**
+     * Indicates that this segment provider is providing segments for an active track and should be prioritized
+     * accordingly.
+     * Time ranges to be prefetched will change to the active prefetch window.
+     */
+    activate(): void;
+    /**
+     * Deactivates the segment provider.
+     * This clears cached segments not within the inactive prefetch range.
+     * Time ranges to be prefetched will change to the inactive prefetch window.
+     */
+    deactivate(): void;
+    clear(): void;
+    reset(): void;
+    /**
+     * Resets the slot if it's in an error state.
+     * @param slot
+     */
+    private resetSlot;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=SegmentControllerImpl.d.ts.map

package/dist/types/current/streaming/SegmentControllerImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SegmentControllerImpl.d.ts","sourceRoot":"","sources":["../../../../src/streaming/SegmentControllerImpl.ts"],"names":[],"mappings":"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"}

package/dist/types/current/streaming/SegmentControllerImpl.js

@@ -0,0 +1,494 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Abort, clone, closeTo, createDisposer, EventHostImpl, getNetworkState, getOrSet, isSilentError, logDebug, logError, noop, rangeIntersects, RangesImpl, throttle, withAbort, } from '@amazon/vinyl-util';
+import { SEGMENT_START_AFFORDANCE, } from '../streaming/SegmentController';
+import { SegmentDataSlot, SegmentStatus, } from '../streaming/SegmentDataSlot';
+import { defaultTrackPriority, enqueueSegmentPrefetch, immediatePrefetchPriority, } from '../streaming/SegmentPrefetch';
+import { getSegmentAtTime, getSegmentInsertionIndexAtTime, } from '../streaming/util/segment';
+import { getMediaPeriodAtTime, } from '../streaming/MediaTimeline';
+/**
+ * The interval to check if additional segments should be prefetched.
+ */
+export const PREFETCH_POLL_THROTTLE = 1;
+export const defaultSegmentControllerBaseOptions = {
+    prefetchActive: 180,
+    prefetchInactive: 20,
+    retainTail: 30,
+};
+/**
+ * Default SegmentController implementation.
+ * Provides segments for a given time.
+ * Handles segment prefetching and caching.
+ *
+ * Uses mediaTimelineTransformed to resolve segments directly from the MediaTimeline.
+ */
+export class SegmentControllerImpl extends EventHostImpl {
+    deps;
+    contentType;
+    get [Symbol.toStringTag]() {
+        return 'SegmentControllerImpl';
+    }
+    _active = false;
+    get active() {
+        return this._active;
+    }
+    _fetchedRanges = new RangesImpl();
+    _startTime = 0;
+    /**
+     * A map of decoder id to init segment slots.
+     * This allows representations with seamless bitstream switching to share initialization segments without
+     * making unnecessary requests or decoder re-initializations.
+     */
+    cachedInitSegments = new Map();
+    cachedSegments = [];
+    disposer = createDisposer();
+    options;
+    prefetchingPriority = clone(defaultTrackPriority);
+    /**
+     * True if the last segment in the prefetch range has been cached.
+     */
+    ended = false;
+    prefetching = false;
+    _error = null;
+    timeUpdateSub = null;
+    seekingSub = null;
+    // When disposed, aborts in-flight operations.
+    abort = new Abort();
+    /**
+     * Cached last period lookup for fast repeated access.
+     */
+    _cachedPeriod = null;
+    constructor(deps, contentType, options) {
+        super();
+        this.deps = deps;
+        this.contentType = contentType;
+        logDebug(this, 'constructed');
+        const { add } = this.disposer;
+        this.options = {
+            ...defaultSegmentControllerBaseOptions,
+            ...options,
+        };
+        add(deps.mediaTimelineTransformed.onData(() => {
+            // If the media timeline changes, re-check ended state.
+            this.ended = false;
+            this._cachedPeriod = null;
+            this.pollPrefetch();
+            this.dispatch('change', {});
+        }));
+        add(getNetworkState().on('online', () => {
+            logDebug(this, 'online, resetting prefetch');
+            this.reset();
+        }));
+    }
+    get error() {
+        return this._error;
+    }
+    async getDuration() {
+        const timeline = await this.deps.mediaTimelineTransformed.value;
+        if (timeline.getDuration)
+            return timeline.getDuration();
+        const periods = timeline.periods;
+        if (periods.length === 0)
+            return null;
+        const last = periods[periods.length - 1];
+        return last.endTime === Infinity ? null : last.endTime;
+    }
+    /**
+     * Gets the period at the given time, using a cache for the last returned period.
+     */
+    async getPeriodAtTime(time) {
+        if (this._cachedPeriod &&
+            time >= this._cachedPeriod.startTime &&
+            time < this._cachedPeriod.endTime) {
+            return this._cachedPeriod;
+        }
+        const timeline = await this.deps.mediaTimelineTransformed.value;
+        const period = getMediaPeriodAtTime(timeline, time);
+        if (period)
+            this._cachedPeriod = period;
+        return period;
+    }
+    /**
+     * Configures this segment provider and initiates prefetching.
+     * This may be called multiple times, for example when re-using a cached track a new track priority and start time
+     * can be provided.
+     */
+    configure(options) {
+        if (options.startTime != null)
+            this._startTime = options.startTime;
+        if (options.trackPrefetchPriority != null)
+            this.prefetchingPriority.trackPriority =
+                options.trackPrefetchPriority;
+        this.ended = false;
+        this.pollPrefetch();
+    }
+    get startTime() {
+        return this._startTime;
+    }
+    get trackPrefetchPriority() {
+        return this.prefetchingPriority.trackPriority;
+    }
+    /**
+     * Returns the range that should be prefetched.
+     */
+    get prefetchRange() {
+        return this.active
+            ? this.prefetchRangeActive
+            : this.prefetchRangeInactive;
+    }
+    /**
+     * Returns the range that should be prefetched when inactive.
+     * This range will not be removed during sweeps unless `clear` is called.
+     */
+    get prefetchRangeInactive() {
+        const prefetchFrom = this.startTime;
+        const prefetchTo = prefetchFrom + this.options.prefetchInactive;
+        return [prefetchFrom, prefetchTo];
+    }
+    /**
+     * Returns the range that should be prefetched while active.
+     */
+    get prefetchRangeActive() {
+        const prefetchFrom = this.deps.playbackController.currentTime;
+        const prefetchTo = prefetchFrom + this.options.prefetchActive;
+        return [prefetchFrom, prefetchTo];
+    }
+    /**
+     * Clears data segments no longer within the current prefetch range.
+     * Init segments will not be changed.
+     */
+    sweepCachedSegments() {
+        // The inactive range (typically first couple segments of a track) will not be removed.
+        const inactiveRange = this.prefetchRangeInactive;
+        // The active range prefetch expanded to include the retain tail will not be removed if the track is active.
+        const activeRange = this.active
+            ? [
+                this.prefetchRangeActive[0] - this.options.retainTail,
+                this.prefetchRangeActive[1],
+            ]
+            : null;
+        let n = this.cachedSegments.length;
+        for (let i = 0; i < n; i++) {
+            const cachedSegment = this.cachedSegments[i];
+            // Check if the cached segment is still within our retain window.
+            const { startTime, endTime } = cachedSegment;
+            const cachedRange = [startTime, endTime];
+            if (!rangeIntersects(inactiveRange, cachedRange) &&
+                !(activeRange && rangeIntersects(activeRange, cachedRange))) {
+                // No longer need the segment. Does nothing if inactive.
+                cachedSegment.data.clear();
+                this.cachedSegments.splice(i, 1);
+                logDebug(this, 'removing cached segment at: ', cachedSegment.startTime);
+                i--;
+                n--;
+            }
+        }
+    }
+    /**
+     * Gets the next time to prefetch, or null if the prefetch range has been filled.
+     */
+    getNextTimeToPrefetch() {
+        const [prefetchFrom, prefetchTo] = this.prefetchRange;
+        // fetchedRanges are directly from the segments, safe to use when getting next segment.
+        const currentRange = this.fetchedRanges.getRangeAt(prefetchFrom);
+        const nextTime = currentRange == null ? prefetchFrom : currentRange[1];
+        if (nextTime >= prefetchTo - Number.EPSILON)
+            return null;
+        return nextTime;
+    }
+    pollPrefetch = this.disposer.add(throttle(() => {
+        if (this.error)
+            return;
+        this.sweepCachedSegments();
+        if (this.ended || this.prefetching)
+            return;
+        const nextTime = this.getNextTimeToPrefetch();
+        if (nextTime == null)
+            return; // Prefetched the full range
+        this.prefetching = true;
+        // Enqueue the prefetch.
+        enqueueSegmentPrefetch(async () => {
+            this.abort.throwIfAborted();
+            // Quality selection is done at the time of getSegment(), which is called when
+            // a slot is created. Defer slot creation until request is about to be made.
+            logDebug(this, `Prefetching`, nextTime.toFixed(4));
+            const slot = await this.getSlotAtTime(nextTime);
+            this.abort.throwIfAborted();
+            if (!slot) {
+                logDebug(this, 'prefetch ended');
+                this.ended = true;
+                return;
+            }
+            await withAbort(Promise.all([
+                slot.initData.request(),
+                slot.data.request(),
+            ]), this.abort);
+        }, this.contentType, this.prefetchingPriority)
+            .catch(this.prefetchErrorHandler)
+            .finally(() => {
+            this.prefetching = false;
+            if (!this.disposed)
+                this.pollPrefetch();
+        });
+    }, PREFETCH_POLL_THROTTLE, {
+        leading: true,
+        trailing: true,
+    }));
+    prefetchErrorHandler = (error) => {
+        // Only log the error for prefetch failures, it will get reported if/when it is attempted
+        // to be buffered.
+        if (!isSilentError(error)) {
+            logError(this, 'Error prefetching segment', error);
+            this._error = error;
+        }
+    };
+    get fetchedRanges() {
+        return this._fetchedRanges;
+    }
+    /**
+     * Gets the number of seconds currently prefetched.
+     */
+    get fetchedTime() {
+        const time = this.active
+            ? this.deps.playbackController.currentTime
+            : this._startTime;
+        const currentRange = this.fetchedRanges.getRangeAt(time);
+        if (!currentRange)
+            return 0;
+        return currentRange[1] - time;
+    }
+    _streamingQuality = null;
+    get streamingQuality() {
+        return this._streamingQuality;
+    }
+    set streamingQuality(value) {
+        const previous = this._streamingQuality;
+        if (value?.qualityId === previous?.qualityId)
+            return;
+        this._streamingQuality = value;
+        logDebug(this, 'streamingQualityChange', value);
+        this.dispatch('streamingQualityChange', {
+            previous,
+            current: value,
+        });
+    }
+    getSegment(time, abort) {
+        logDebug(this, `requesting segment at time: ${time.toFixed(4)}`);
+        const segmentReferencePromise = withAbort(this._getSegment(Math.max(0, time)), abort);
+        // When a segment is actively needed, block the prefetch queue until the active segment promise settles:
+        enqueueSegmentPrefetch(() => segmentReferencePromise, this.contentType, immediatePrefetchPriority).catch(noop);
+        return segmentReferencePromise;
+    }
+    async _getSegment(time) {
+        const streamingSlot = await this.getSlotAtTime(time);
+        if (!streamingSlot)
+            return null;
+        logDebug(this, `init status: ${streamingSlot.initData.status}, data status: ${streamingSlot.data.status}`);
+        // If prefetch failed, try again now that the segment is actively needed:
+        this.resetSlot(streamingSlot);
+        const initAndDataPromise = Promise.all([
+            streamingSlot.initData.request(),
+            streamingSlot.data.request(),
+        ]);
+        // If the requested time is close to the start of the next segment, immediately start prefetching the next
+        // segment, and not resolving until both are cached.
+        let minBufferPrefetch = Promise.resolve();
+        const minBufferTime = await this.getMinBufferTime();
+        if (streamingSlot.endTime - time < minBufferTime) {
+            minBufferPrefetch = this.prefetchImmediate(streamingSlot.endTime).catch(noop); // Ignore error until it is the next segment needed
+        }
+        const [initData, data] = await initAndDataPromise;
+        await minBufferPrefetch;
+        return {
+            ...streamingSlot,
+            initData,
+            data,
+        };
+    }
+    /**
+     * Gets the minimum buffer time from the timeline.
+     * Falls back to a reasonable default.
+     */
+    async getMinBufferTime() {
+        const timeline = await this.deps.mediaTimelineTransformed.value;
+        return timeline.minBufferTime;
+    }
+    /**
+     * Prefetches the segment at the given time. Does not use the background scheduler.
+     *
+     * @param time
+     */
+    async prefetchImmediate(time) {
+        const slot = await this.getSlotAtTime(time);
+        if (!slot)
+            return;
+        await Promise.all([slot.initData.request(), slot.data.request()]);
+    }
+    /**
+     * Gets a streaming segment slot that spans the given time, or null if there is no media at that time.
+     * Slots will be cached until they slide out of the retention range or `clear` is called.
+     */
+    async getSlotAtTime(time) {
+        // Check if there is a cached slot.
+        const cachedSegment = getSegmentAtTime(time, this.cachedSegments, SEGMENT_START_AFFORDANCE);
+        if (cachedSegment)
+            return cachedSegment;
+        const newSlot = await withAbort(this.createSlotForTime(time), this.abort);
+        this.abort.throwIfAborted();
+        if (!newSlot)
+            return null;
+        newSlot.data.onStatusChange = () => {
+            // When the data segment settles, update the fetched ranges.
+            if (newSlot.data.status === SegmentStatus.RESOLVED)
+                this._fetchedRanges.add(newSlot.startTime, newSlot.endTime);
+            else if (newSlot.data.status === SegmentStatus.INACTIVE)
+                this._fetchedRanges.remove(newSlot.startTime, newSlot.endTime);
+            this.dispatch('fetchedRangesChange', {});
+        };
+        // Insert the slot, in order.
+        const insertionIndex = getSegmentInsertionIndexAtTime(newSlot.startTime, this.cachedSegments);
+        // Slot creation is asynchronous, to allow requesting index ranges. Check if a slot for this time was already
+        // created.
+        if (insertionIndex > 0) {
+            const cachedSegment = this.cachedSegments[insertionIndex - 1];
+            if (closeTo(newSlot.startTime, cachedSegment.startTime)) {
+                return cachedSegment;
+            }
+        }
+        logDebug(this, `created slot at ${insertionIndex} for time ${newSlot.startTime.toFixed(4)}`);
+        this.cachedSegments.splice(insertionIndex, 0, newSlot);
+        return newSlot;
+    }
+    /**
+     * Gets a cached init segment slot for the given decoder id. If a slot is not cached, create one.
+     */
+    getOrCreateInitSlot(decoderId, segmentDataProvider) {
+        return getOrSet(this.cachedInitSegments, decoderId, () => {
+            return new SegmentDataSlot(segmentDataProvider);
+        });
+    }
+    /**
+     * Creates a slot that spans the given time, or returns null if there is no media at that time.
+     * Uses the mediaTimelineTransformed to resolve segments directly.
+     */
+    async createSlotForTime(time) {
+        const period = await this.getPeriodAtTime(time);
+        if (!period)
+            return null;
+        // Filter qualities to this content type.
+        const filteredQualities = period.qualities.filter((q) => q.metadata.contentType === this.contentType);
+        if (filteredQualities.length === 0)
+            return null;
+        // Gets the preceding segment encoding metadata for quality selection.
+        let previousQuality = null;
+        const previousIndex = getSegmentInsertionIndexAtTime(time, this.cachedSegments) - 1;
+        if (previousIndex >= 0)
+            previousQuality = this.cachedSegments[previousIndex].quality;
+        const prefetchState = {
+            fetchedTime: this.fetchedTime,
+            previousQuality,
+            active: this.active,
+        };
+        const metadataArray = filteredQualities.map((q) => q.metadata);
+        const index = this.deps.qualitySelector.selectQuality(metadataArray, prefetchState);
+        const selectedQuality = filteredQualities[index];
+        const segment = await selectedQuality.getSegment(time, SEGMENT_START_AFFORDANCE);
+        this.abort.throwIfAborted();
+        this.streamingQuality = segment?.quality ?? null;
+        if (!segment)
+            return null;
+        return {
+            ...segment,
+            quality: segment.quality,
+            initData: this.getOrCreateInitSlot(segment.quality.decoderId, segment.initData),
+            data: new SegmentDataSlot(segment.data),
+        };
+    }
+    /**
+     * Indicates that this segment provider is providing segments for an active track and should be prioritized
+     * accordingly.
+     * Time ranges to be prefetched will change to the active prefetch window.
+     */
+    activate() {
+        if (this._active)
+            return;
+        logDebug(this, 'activate');
+        this._active = true;
+        this.pollPrefetch();
+        const playbackController = this.deps.playbackController;
+        this.timeUpdateSub = playbackController.on('timeUpdate', this.pollPrefetch);
+        this.seekingSub = playbackController.on('seeking', () => {
+            this.ended = false;
+            this._error = null;
+            this.pollPrefetch();
+        });
+    }
+    /**
+     * Deactivates the segment provider.
+     * This clears cached segments not within the inactive prefetch range.
+     * Time ranges to be prefetched will change to the inactive prefetch window.
+     */
+    deactivate() {
+        if (!this._active)
+            return;
+        logDebug(this, 'deactivate');
+        this._active = false;
+        this.sweepCachedSegments();
+        this.timeUpdateSub();
+        this.timeUpdateSub = null;
+        this.seekingSub();
+        this.seekingSub = null;
+    }
+    clear() {
+        logDebug(this, 'clear');
+        this.cachedSegments.forEach((slot) => {
+            slot.data.onStatusChange = null;
+            slot.data.clear();
+            slot.initData.clear();
+        });
+        this.cachedSegments.length = 0;
+        this.cachedInitSegments.clear();
+        this._fetchedRanges.clear();
+        this.ended = false;
+        this._error = null;
+        this._cachedPeriod = null;
+        if (!this.disposed)
+            this.pollPrefetch();
+        this.dispatch('fetchedRangesChange', {});
+    }
+    reset() {
+        logDebug(this, 'reset');
+        this.cachedSegments.forEach((slot) => this.resetSlot(slot));
+        this._error = null;
+        this.pollPrefetch();
+    }
+    /**
+     * Resets the slot if it's in an error state.
+     * @param slot
+     */
+    resetSlot(slot) {
+        if (slot.data.status === SegmentStatus.ERRED) {
+            logDebug(this, 'resetting failed segment at time:', slot.startTime);
+            this.ended = false;
+            slot.data.clear();
+        }
+        if (slot.initData.status === SegmentStatus.ERRED) {
+            logDebug(this, 'resetting failed init segment');
+            this.ended = false;
+            slot.initData.clear();
+        }
+    }
+    get disposed() {
+        return this.disposer.disposed;
+    }
+    dispose() {
+        logDebug(this, 'disposing');
+        super.dispose();
+        this.disposer.dispose();
+        this.deactivate();
+        this.clear();
+        this.abort.abort();
+    }
+}