nativescript-spotify
Version:
Spotify for your NativeScript app.
427 lines • 17.1 kB
JavaScript
var observable_1 = require('data/observable');
var common_1 = require('../common');
var auth_1 = require('./auth');
var app = require('application');
var http = require('http');
var Config = com.spotify.sdk.android.player.Config;
var Spotify = com.spotify.sdk.android.player.Spotify;
var Player = com.spotify.sdk.android.player.Player;
var PlayerState = com.spotify.sdk.android.player.PlayerState;
var PlayerStateCallback = com.spotify.sdk.android.player.PlayerStateCallback;
var PlayerNotificationCallback = com.spotify.sdk.android.player.PlayerNotificationCallback;
var Builder = com.spotify.sdk.android.player.Player.Builder;
var AudioController = com.spotify.sdk.android.player.AudioController;
var CustomAudioController = (function (_super) {
__extends(CustomAudioController, _super);
function CustomAudioController() {
_super.call(this);
this.audioTrack = null;
this.savedVolume = null;
return global.__native(this);
}
CustomAudioController.prototype.start = function () {
console.log("Starting");
};
CustomAudioController.prototype.stop = function () {
console.log("Stopping");
};
CustomAudioController.prototype.onAudioDataDelivered = function (frames, numFrames, sampleRate, channels) {
if (!this.audioTrack) {
var size = android.media.AudioTrack.getMinBufferSize(sampleRate, channels, 2);
this.audioTrack = new android.media.AudioTrack(android.media.AudioManager.STREAM_MUSIC, sampleRate, channels, 2, size, android.media.AudioTrack.MODE_STREAM);
if (this.savedVolume !== null) {
this.audioTrack.setVolume(this.savedVolume);
}
this.audioTrack.play();
}
var newSize = this.audioTrack.write(frames, 0, numFrames);
return newSize;
};
CustomAudioController.prototype.onAudioFlush = function () {
console.log("Flushing");
if (this.audioTrack) {
this.audioTrack.flush();
}
};
CustomAudioController.prototype.onAudioPaused = function () {
console.log("Pausing");
if (this.audioTrack) {
this.audioTrack.pause();
}
};
CustomAudioController.prototype.onAudioResumed = function () {
console.log("Resuming");
if (this.audioTrack) {
this.audioTrack.play();
}
};
CustomAudioController.prototype.setVolume = function (val) {
if (this.audioTrack) {
this.audioTrack.setVolume(val);
}
this.savedVolume = val;
};
return CustomAudioController;
}(AudioController));
var TNSSpotifyPlayer = (function () {
function TNSSpotifyPlayer() {
this._started = false;
this._loggedIn = false;
this._playerLoggedIn = false;
this._playing = false;
}
TNSSpotifyPlayer.prototype.initPlayer = function (emitEvents) {
var _this = this;
this.auth = new auth_1.TNSSpotifyAuth();
if (emitEvents) {
this.auth.setupEvents();
this.setupEvents();
}
auth_1.TNSSpotifyAuth.VERIFY_SESSION().then(function () {
_this.setLoggedIn(true);
_this.playerReady();
}, function () {
_this.setLoggedIn(false);
_this.playerReady();
});
};
TNSSpotifyPlayer.prototype.isLoggedIn = function () {
return this.player.isLoggedIn();
};
TNSSpotifyPlayer.prototype.togglePlay = function (track, force) {
var _this = this;
return new Promise(function (resolve, reject) {
if (track && (track !== _this._loadedTrack)) {
_this.play(track).then(resolve, reject);
}
else if (_this.player) {
_this._playing = typeof force !== 'undefined' ? force : !_this._playing;
if (_this._playing) {
_this.player.resume();
}
else {
_this.player.pause();
}
resolve(_this._playing);
}
});
};
TNSSpotifyPlayer.prototype.isPlaying = function () {
return this._playing;
};
TNSSpotifyPlayer.prototype.getPlayerState = function () {
var _this = this;
return new Promise(function (resolve, reject) {
try {
_this.player.getPlayerState(new PlayerStateCallback({
onPlayerState: function (playerState) {
var resp = {
activeDevice: playerState.activeDevice,
duration: playerState.durationInMs,
playing: playerState.playing,
position: playerState.positionInMs,
repeating: playerState.repeating,
shuffling: playerState.shuffling,
trackUri: playerState.trackUri
};
resolve(resp);
}
}));
}
catch (err) {
reject(err);
}
});
};
TNSSpotifyPlayer.prototype.setShuffle = function (enabled) {
this.player.setShuffle(enabled);
};
TNSSpotifyPlayer.prototype.setRepeat = function (enabled) {
this.player.setRepeat(enabled);
};
TNSSpotifyPlayer.prototype.seekToPosition = function (position) {
this.player.seekToPosition(position);
};
TNSSpotifyPlayer.prototype.loadedTrack = function () {
return this._loadedTrack;
};
TNSSpotifyPlayer.prototype.setVolume = function (val) {
var _this = this;
return new Promise(function (resolve, reject) {
if (_this._audioController) {
_this._audioController.setVolume(val);
resolve();
}
else {
reject();
}
});
};
TNSSpotifyPlayer.prototype.play = function (track) {
var _this = this;
return new Promise(function (resolve, reject) {
_this.checkPlayer().then(function () {
if (!_this._playerLoggedIn) {
_this._playerLoggedIn = true;
}
_this.playUri(track, resolve, reject);
}, function () {
reject('login');
});
});
};
TNSSpotifyPlayer.prototype.playUri = function (track, resolve, reject) {
console.log("playUri", this.player);
this.player.play(track);
this._loadedTrack = track;
this._playing = true;
resolve(true);
};
TNSSpotifyPlayer.prototype.checkPlayer = function () {
var _this = this;
return new Promise(function (resolve, reject) {
if (!_this._started) {
if (_this.player) {
try {
console.log("calling Spotify.destroyPlayer...");
var activity_1 = app.android.startActivity || app.android.foregroundActivity;
Spotify.destroyPlayer(activity_1);
console.log("TimeUnit:");
console.log(TimeUnit);
if (typeof TimeUnit !== 'undefined')
_this.player.awaitTermination(10, TimeUnit.SECONDS);
}
catch (err) {
console.log("Spotify.destroyPlayer catch:");
console.log(err);
}
_this.player = undefined;
}
var activity = app.android.startActivity || app.android.foregroundActivity;
var playerConfig = new Config(activity, auth_1.TNSSpotifyAuth.SESSION, common_1.TNSSpotifyConstants.CLIENT_ID);
var builder = new Builder(playerConfig);
_this._audioController = new CustomAudioController();
builder.setAudioController(_this._audioController);
var observer = new Player.InitializationObserver({
onError: function (throwable) {
var msg = throwable.getMessage();
console.log("MainActivity", "Could not initialize player: " + msg);
reject(msg);
},
onInitialized: function (player) {
console.log("player initialized", player);
_this._started = true;
auth_1.TNSSpotifyAuth.CHECK_PREMIUM().then(function () {
console.log("user is premium/unlimited...");
resolve();
}, function () {
reject();
});
}
});
_this.player = builder.build(observer);
_this.player.addPlayerNotificationCallback(new PlayerNotificationCallback({
onPlaybackEvent: function (eventType, playerState) {
console.log('EVENT TYPE: ', eventType);
console.log('PLAYER STATE: ', playerState);
if (_this._loadedTrack && (eventType == PlayerNotificationCallback.EventType.TRACK_CHANGED || eventType == PlayerNotificationCallback.EventType.END_OF_CONTEXT)) {
eventType = eventType == PlayerNotificationCallback.EventType.END_OF_CONTEXT ? 'TRACK_END' : eventType;
if (_this.events && playerState.trackUri) {
if (_this._trackTimeout) {
clearTimeout(_this._trackTimeout);
}
_this._trackTimeout = setTimeout(function () {
var trackId = playerState.trackUri.split(':').slice(-1);
console.log("trackId: " + trackId);
http.request({
url: "https://api.spotify.com/v1/tracks/" + trackId,
method: 'GET',
headers: { "Content-Type": "application/json", "Authorization:": "Bearer " + auth_1.TNSSpotifyAuth.SESSION }
}).then(function (res) {
if (res && res.content) {
var track_1 = JSON.parse(res.content);
_this._changedPlaybackState.data.state = {
currentTrack: {
uri: track_1.uri,
name: track_1.name,
albumName: track_1.album.name,
artistName: track_1.artists[0].name,
durationMs: track_1.duration_ms,
positionInMs: playerState.positionInMs,
eventType: eventType
}
};
_this.events.notify(_this._changedPlaybackState);
setTimeout(function () {
if (track_1.album && track_1.album.images) {
_this._albumArtChange.data.url = track_1.album.images[0].url;
_this.events.notify(_this._albumArtChange);
}
}, 100);
}
}, function (err) {
console.log("track data error:", err);
});
}, 500);
}
}
},
onPlaybackError: function (errorType, errorDetails) {
console.log('ERROR TYPE: ', errorType);
console.log('ERROR DETAILS: ', errorDetails);
if (errorDetails) {
for (var key in errorDetails) {
console.log("key: " + key, errorDetails[key]);
}
}
}
}));
}
else {
resolve();
}
});
};
TNSSpotifyPlayer.prototype.isLoginError = function (desc) {
if (desc.indexOf('invalid credentials') > -1 || desc.indexOf('NULL') > -1) {
return true;
}
else {
return false;
}
};
TNSSpotifyPlayer.prototype.loginError = function () {
this.setLoggedIn(false);
common_1.Utils.alert('You need to login to renew your session.');
};
TNSSpotifyPlayer.prototype.setLoggedIn = function (value) {
this._loggedIn = value;
if (!value) {
this._playerLoggedIn = false;
this._started = false;
console.log("TODO: player dispose()");
}
};
TNSSpotifyPlayer.prototype.playerReady = function () {
if (this.events) {
this._playerReady.data.loggedIn = this._loggedIn;
this.events.notify(this._playerReady);
}
};
TNSSpotifyPlayer.prototype.setupEvents = function () {
var _this = this;
this.auth.events.on('authLoginChange', function (eventData) {
console.log("this.auth.events.on('authLoginChange'", eventData.data.status);
_this.setLoggedIn(eventData.data.status);
});
this.events = new observable_1.Observable();
this._albumArtChange = {
eventName: 'albumArtChange',
data: {
url: ''
}
};
this._playerReady = {
eventName: 'playerReady',
data: {
loggedIn: false
}
};
this._changedPlaybackStatus = {
eventName: 'changedPlaybackStatus',
data: {
playing: false
}
};
this._changedPlaybackState = {
eventName: 'changedPlaybackState',
data: {
state: {}
}
};
this._seekedToOffset = {
eventName: 'seekedToOffset',
data: {
offset: 0
}
};
this._changedVolume = {
eventName: 'changedVolume',
data: {
volume: 0
}
};
this._changedShuffleStatus = {
eventName: 'changedShuffleStatus',
data: {
shuffle: false
}
};
this._changedRepeatStatus = {
eventName: 'changedRepeatStatus',
data: {
repeat: false
}
};
this._changedToTrack = {
eventName: 'changedToTrack',
data: {
metadata: null
}
};
this._failedToPlayTrack = {
eventName: 'failedToPlayTrack',
data: {
url: null
}
};
this._startedPlayingTrack = {
eventName: 'startedPlayingTrack',
data: {
url: null
}
};
this._stoppedPlayingTrack = {
eventName: 'stoppedPlayingTrack',
data: {
url: null
}
};
this._skippedToNextTrack = {
eventName: 'skippedToNextTrack'
};
this._skippedToPreviousTrack = {
eventName: 'skippedToPreviousTrack'
};
this._activePlaybackDevice = {
eventName: 'activePlaybackDevice'
};
this._inactivePlaybackDevice = {
eventName: 'inactivePlaybackDevice'
};
this._poppedQueue = {
eventName: 'poppedQueue'
};
this._temporaryConnectionError = {
eventName: 'temporaryConnectionError'
};
this._streamError = {
eventName: 'streamError',
data: {
error: null
}
};
this._receivedMessage = {
eventName: 'receivedMessage',
data: {
message: null
}
};
this._streamDisconnected = {
eventName: 'streamDisconnected'
};
};
return TNSSpotifyPlayer;
}());
exports.TNSSpotifyPlayer = TNSSpotifyPlayer;
//# sourceMappingURL=player.js.map