@martin-juul/nativescript-astreamer
Version:
NativeScript plugin to play audio from filesystem and network.
339 lines (338 loc) • 13.2 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var observable_1 = require("tns-core-modules/data/observable");
var file_system_1 = require("tns-core-modules/file-system");
var types_1 = require("tns-core-modules/utils/types");
var common_1 = require("../common");
var options_1 = require("../options");
var NSAudioPlayer = (function (_super) {
__extends(NSAudioPlayer, _super);
function NSAudioPlayer() {
var _this = _super.call(this) || this;
_this.log = new common_1.NS_AUDIO_LOGGER('ios');
return _this;
}
Object.defineProperty(NSAudioPlayer.prototype, "events", {
get: function () {
if (!this._events) {
this._events = new observable_1.Observable();
}
return this._events;
},
enumerable: true,
configurable: true
});
Object.defineProperty(NSAudioPlayer.prototype, "ios", {
get: function () {
return this._player;
},
enumerable: true,
configurable: true
});
Object.defineProperty(NSAudioPlayer.prototype, "debug", {
set: function (value) {
common_1.NS_AUDIO_UTIL.debug = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(NSAudioPlayer.prototype, "volume", {
get: function () {
return this._player ? this._player.volume : 0;
},
set: function (value) {
if (this._player && value >= 0) {
this._player.volume = value;
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(NSAudioPlayer.prototype, "duration", {
get: function () {
if (this._player && this._player.currentItem) {
var seconds = CMTimeGetSeconds(this._player.currentItem.asset.duration);
return seconds * 1000.0;
}
return 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(NSAudioPlayer.prototype, "currentTime", {
get: function () {
if (this._player && this._player.currentItem) {
var currentTime = this._player.currentTime();
return ((currentTime.value / currentTime.timescale) * 1000);
}
return 0;
},
enumerable: true,
configurable: true
});
NSAudioPlayer.prototype.initFromFile = function (options) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
options.autoPlay = false;
return [2, this.playFromFile(options)];
});
});
};
NSAudioPlayer.prototype.playFromFile = function (options) {
return __awaiter(this, void 0, void 0, function () {
var fileName;
return __generator(this, function (_a) {
this._statusObserver = PlayerObserverClass.alloc();
this._statusObserver['_owner'] = this;
fileName = types_1.isString(options.audioFile) ? options.audioFile.trim() : '';
if (fileName.indexOf('~/') === 0) {
fileName = file_system_1.path.join(file_system_1.knownFolders.currentApp().path, fileName.replace('~/', ''));
}
this.log.info("playFromFile: filename " + fileName);
this._setIOSAudioSessionOutput();
this._setupPlayerItem(fileName, true);
if (options.loop) {
NSNotificationCenter.defaultCenter.addObserverSelectorNameObject(this, 'playerItemDidReachEnd', AVPlayerItemDidPlayToEndTimeNotification, this._player.currentItem);
}
if (options.autoPlay) {
this._player.play();
}
return [2];
});
});
};
NSAudioPlayer.prototype.playerItemDidReachEnd = function () {
if (this._player) {
this._player.seekToTime(kCMTimeZero);
this._player.play();
}
};
NSAudioPlayer.prototype.initFromUrl = function (options) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
options.autoPlay = false;
return [2, this.playFromUrl(options)];
});
});
};
NSAudioPlayer.prototype.playFromUrl = function (options) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
this._statusObserver = PlayerObserverClass.alloc();
this._statusObserver['_owner'] = this;
this._setIOSAudioSessionOutput();
this._setupPlayerItem(options.audioFile, false);
return [2];
});
});
};
NSAudioPlayer.prototype.pause = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
if (!this._player) {
throw new Error('Player not initialized.');
}
try {
if (this._player && this._player.timeControlStatus === 2) {
this.log.info('pause(): pausing player');
this._player.pause();
this._sendEvent(options_1.AudioPlayerEvent.PAUSED);
return [2, true];
}
}
catch (e) {
this.log.error('pause(): error', e);
throw e;
}
return [2];
});
});
};
NSAudioPlayer.prototype.play = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
try {
if (!this.isAudioPlaying()) {
this.log.info('play(): changed state from paused to playing');
this._player.play();
return [2, true];
}
}
catch (e) {
this.log.error('play(): threw an exception', e);
throw e;
}
return [2];
});
});
};
NSAudioPlayer.prototype.resume = function () {
if (this._player && this._player.currentItem) {
this.log.info('resume(): called');
this._player.play();
}
};
NSAudioPlayer.prototype.playAtTime = function (time) {
if (this._player && this._player.currentItem) {
this.log.info('playAtTime()', time);
this._player.seekToTime(CMTimeMakeWithSeconds(time, 1000));
}
};
NSAudioPlayer.prototype.seekTo = function (time) {
return __awaiter(this, void 0, void 0, function () {
var currentItem, readyToPlay;
return __generator(this, function (_a) {
currentItem = this._player.currentItem;
if (!currentItem) {
this.log.error('seekTo(): player does not have an item', {
platform: 'ios',
});
return [2, false];
}
readyToPlay = currentItem.status === 1;
if (!readyToPlay) {
this.log.error('seekTo(): item was not ready to play');
return [2, false];
}
try {
this._player.seekToTime(CMTimeMakeWithSeconds(time, 1000));
this._sendEvent(options_1.AudioPlayerEvent.SEEK);
this.log.info("seekTo(): seeked to " + time);
}
catch (e) {
this.log.error('seekTo(): an exception', e);
throw e;
}
return [2, true];
});
});
};
NSAudioPlayer.prototype.dispose = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
try {
this.log.info('disposing player');
if (this._player) {
if (this._player.currentItem) {
this._removeStatusObserver(this._player.currentItem);
}
this._player.pause();
this._player.replaceCurrentItemWithPlayerItem(null);
this._player = null;
}
return [2, true];
}
catch (e) {
this.log.error('dispose(): threw an exception', e);
throw e;
}
return [2];
});
});
};
NSAudioPlayer.prototype.isAudioPlaying = function () {
return this._player &&
this._player.timeControlStatus === 2;
};
NSAudioPlayer.prototype.getAudioTrackDuration = function () {
return __awaiter(this, void 0, void 0, function () {
var seconds, milliseconds;
return __generator(this, function (_a) {
try {
seconds = CMTimeGetSeconds(this._player.currentItem.asset.duration);
milliseconds = seconds * 1000.0;
this.log.info('audio track duration', milliseconds);
return [2, milliseconds.toString()];
}
catch (e) {
this.log.error('getAudioTrackDuration error', e);
throw e;
}
return [2];
});
});
};
NSAudioPlayer.prototype.changePlayerSpeed = function (speed) {
if (this._player && speed) {
if (typeof speed === 'string') {
speed = parseFloat(speed);
}
this._player.rate = speed;
}
};
NSAudioPlayer.prototype._sendEvent = function (eventName, data) {
if (this.events) {
this.events.notify({
eventName: eventName,
object: this,
data: data,
});
}
};
NSAudioPlayer.prototype._setupPlayerItem = function (audioUrl, isLocalFile) {
var url;
if (isLocalFile) {
url = NSURL.fileURLWithPath(audioUrl);
}
else {
url = NSURL.URLWithString(audioUrl);
}
var avAsset = AVURLAsset.URLAssetWithURLOptions(url, null);
var playerItem = AVPlayerItem.playerItemWithAsset(avAsset);
if (this._player && this._player.currentItem) {
this._player.replaceCurrentItemWithPlayerItem(playerItem);
}
else {
this._player = AVPlayer.playerWithPlayerItem(playerItem);
this._player.automaticallyWaitsToMinimizeStalling = false;
}
this._addStatusObserver(playerItem);
};
NSAudioPlayer.prototype._setIOSAudioSessionOutput = function () {
var audioSession = AVAudioSession.sharedInstance();
var output = audioSession.currentRoute.outputs.lastObject.portType;
this.log.info('IOSAudioSessionOutput', output);
if (output.match(/Receiver/)) {
try {
audioSession.setCategoryError(AVAudioSessionCategoryPlayAndRecord);
audioSession.overrideOutputAudioPortError(1936747378);
audioSession.setActiveError(true);
this.log.info('audioSession category set and active');
}
catch (e) {
this.log.error('setting audioSession category failed', e);
throw e;
}
}
};
NSAudioPlayer.prototype._addStatusObserver = function (currentItem) {
this._statusObserverActive = true;
currentItem.addObserverForKeyPathOptionsContext(this._statusObserver, 'status', 0, null);
};
NSAudioPlayer.prototype._removeStatusObserver = function (currentItem) {
if (!this._statusObserverActive) {
return;
}
this._statusObserverActive = false;
if (currentItem) {
currentItem.removeObserverForKeyPath(this._statusObserver, 'status');
}
};
return NSAudioPlayer;
}(NSObject));
exports.NSAudioPlayer = NSAudioPlayer;
var PlayerObserverClass = (function (_super) {
__extends(PlayerObserverClass, _super);
function PlayerObserverClass() {
return _super !== null && _super.apply(this, arguments) || this;
}
PlayerObserverClass.prototype.observeValueForKeyPathOfObjectChangeContext = function (path, obj, change, context) {
if (path === 'status') {
if (this['_owner']._player.currentItem.status === 1) {
this['_owner']._sendEvent(options_1.AudioPlayerEvent.READY);
this['_owner']._player.play();
}
}
};
return PlayerObserverClass;
}(NSObject));