vulcanize

dashboard-ui/cordova/android/androidcredentials.js

@@ -0,0 +1,46 @@
+(function () {
+
+    function updateCredentials() {
+
+        console.log('sending updated credentials to ApiClientBridge');
+
+        var json = JSON.stringify(ConnectionManager.credentialProvider().credentials());
+        var credentials = JSON.parse(json);
+
+        for (var i = 0, length = credentials.Servers.length; i < length; i++) {
+            var server = credentials.Servers[i];
+
+            if (server.DateLastAccessed != null) {
+                server.DateLastAccessed = new Date(server.DateLastAccessed).toISOString();
+            }
+        }
+
+        json = JSON.stringify(credentials);
+        ApiClientBridge.updateCredentials(json);
+    }
+
+    function initNativeConnectionManager() {
+
+        console.log('initNativeConnectionManager');
+
+        var capabilities = ConnectionManager.capabilities();
+
+        ApiClientBridge.init(AppInfo.appName, AppInfo.appVersion, AppInfo.deviceId, AppInfo.deviceName, JSON.stringify(capabilities));
+
+        //initAjax();
+    }
+
+    Events.on(ConnectionManager.credentialProvider(), 'credentialsupdated', updateCredentials);
+
+    updateCredentials();
+    initNativeConnectionManager();
+
+    window.AndroidAjax = {
+
+        onResponse: function (id, status, response) {
+
+            Events.trigger(AndroidAjax, 'response' + id, [status, response]);
+        }
+    };
+
+})();

dashboard-ui/cordova/android/appstorage.js

@@ -0,0 +1,70 @@
+(function (globalScope, localStorage, sessionStorage) {
+
+    function myStore(defaultObject) {
+
+        var self = this;
+        self.localData = {};
+
+        var isDefaultAvailable;
+
+        if (defaultObject) {
+            try {
+                defaultObject.setItem('_test', '0');
+                isDefaultAvailable = true;
+            } catch (e) {
+
+            }
+        }
+
+        self.setItem = function (name, value) {
+
+            if (isDefaultAvailable) {
+                defaultObject.setItem(name, value);
+            } else {
+                self.localData[name] = value;
+            }
+        };
+
+        self.getItem = function (name) {
+
+            if (isDefaultAvailable) {
+                return defaultObject.getItem(name);
+            }
+
+            return self.localData[name];
+        };
+
+        self.removeItem = function (name) {
+
+            if (isDefaultAvailable) {
+                defaultObject.removeItem(name);
+            } else {
+                self.localData[name] = null;
+            }
+        };
+    }
+
+    function preferencesStore() {
+
+        var self = this;
+
+        self.setItem = function (name, value) {
+
+            AndroidSharedPreferences.set(name, value);
+        };
+
+        self.getItem = function (name) {
+
+            return AndroidSharedPreferences.get(name);
+        };
+
+        self.removeItem = function (name) {
+
+            AndroidSharedPreferences.remove(name);
+        };
+    }
+
+    globalScope.appStorage = new preferencesStore();
+    globalScope.sessionStore = new myStore(sessionStorage);
+
+})(window, window.localStorage, window.sessionStorage);

dashboard-ui/cordova/android/filesystem.js

@@ -0,0 +1,14 @@
+(function () {
+
+    window.FileSystemBridge = {
+
+        fileExists: function (path) {
+            return NativeFileSystem.fileExists(path);
+        },
+
+        translateFilePath: function (path) {
+            return 'file://' + NativeFileSystem.translateFilePath(path);
+        }
+    };
+
+})();

dashboard-ui/cordova/android/iap.js

@@ -0,0 +1,61 @@
+(function () {
+
+    var unlockId = "com.mb.android.unlock";
+    var updatedProducts = [];
+
+    function updateProductInfo(id, owned, price) {
+
+        updatedProducts = updatedProducts.filter(function (r) {
+            return r.id != id;
+        });
+
+        var product = {
+            id: id,
+            owned: owned,
+            price: price
+        };
+
+        updatedProducts.push(product);
+
+        Events.trigger(IapManager, 'productupdated', [product]);
+    }
+
+    function getProduct(id) {
+        var products = updatedProducts.filter(function (r) {
+            return r.id == id;
+        });
+
+        return products.length ? products[0] : null;
+    }
+
+    function isPurchaseAvailable(id) {
+
+        return NativeIapManager.isStoreAvailable();
+    }
+
+    function beginPurchase(id) {
+        return MainActivity.beginPurchase(id);
+    }
+
+    function onPurchaseComplete(result) {
+
+        if (result) {
+            refreshPurchases();
+        }
+    }
+
+    function refreshPurchases() {
+        NativeIapManager.isPurchased(unlockId, "window.IapManager.updateProduct");
+    }
+
+    window.IapManager = {
+        isPurchaseAvailable: isPurchaseAvailable,
+        getProductInfo: getProduct,
+        updateProduct: updateProductInfo,
+        beginPurchase: beginPurchase,
+        onPurchaseComplete: onPurchaseComplete
+    };
+
+    refreshPurchases();
+
+})();

dashboard-ui/cordova/android/immersive.js

@@ -0,0 +1,111 @@
+(function () {
+
+    function onSuccess() {
+        console.log('Immersive mode succeeded');
+    }
+
+    function onError() {
+        console.log('Immersive mode failed');
+    }
+
+    //// Is this plugin supported?
+    //AndroidFullScreen.isSupported();
+
+    //// Is immersive mode supported?
+    //AndroidFullScreen.isImmersiveModeSupported(onSuccess, onError);
+
+    //// The width of the screen in immersive mode
+    //AndroidFullScreen.immersiveWidth(trace, onError);
+
+    //// The height of the screen in immersive mode
+    //AndroidFullScreen.immersiveHeight(trace, onError);
+
+    //// Hide system UI until user interacts
+    //AndroidFullScreen.leanMode(onSuccess, onError);
+
+    //// Show system UI
+    //AndroidFullScreen.showSystemUI(onSuccess, onError);
+
+    //// Extend your app underneath the system UI (Android 4.4+ only)
+    //AndroidFullScreen.showUnderSystemUI(onSuccess, onError);
+
+    //// Hide system UI and keep it hidden (Android 4.4+ only)
+    //AndroidFullScreen.immersiveMode(onSuccess, onError);
+
+    var currentPlayer;
+
+    function onPlaybackStart(e, state) {
+
+        var player = this;
+
+        if (player.isLocalPlayer && state.NowPlayingItem && state.NowPlayingItem.MediaType == 'Video') {
+            AndroidFullScreen.immersiveMode(onSuccess, onError);
+        }
+    }
+
+    function onPlaybackStopped(e, state) {
+
+        var player = this;
+
+        if (player.isLocalPlayer && state.NowPlayingItem && state.NowPlayingItem.MediaType == 'Video') {
+
+            if (!AppSettings.enableFullScreen()) {
+                AndroidFullScreen.showSystemUI(onSuccess, onError);
+            }
+        }
+    }
+
+    function bindToPlayer(player) {
+
+        releaseCurrentPlayer();
+
+        currentPlayer = player;
+
+        if (!player.isLocalPlayer) {
+            return;
+        }
+
+        $(player).on('playbackstart.fullscreen', onPlaybackStart)
+            .on('playbackstop.fullscreen', onPlaybackStopped);
+    }
+
+    function releaseCurrentPlayer() {
+
+        if (currentPlayer) {
+
+            $(currentPlayer).off('.fullscreen');
+        }
+    }
+
+    function updateFromSetting(leaveFullScreen) {
+
+        if (AppSettings.enableFullScreen()) {
+            AndroidFullScreen.immersiveMode(onSuccess, onError);
+        }
+        else if (leaveFullScreen) {
+            AndroidFullScreen.showSystemUI(onSuccess, onError);
+        }
+    }
+
+    Dashboard.ready(function () {
+
+        console.log('binding fullscreen to MediaController');
+
+        $(MediaController).on('playerchange', function () {
+
+            bindToPlayer(MediaController.getCurrentPlayer());
+        });
+
+        bindToPlayer(MediaController.getCurrentPlayer());
+
+        updateFromSetting(false);
+
+        $(AppSettings).on('settingupdated', function (e, key) {
+
+            if (key == 'enableFullScreen') {
+                updateFromSetting(true);
+            }
+        });
+    });
+
+})();

dashboard-ui/cordova/android/localassetmanager.js

@@ -0,0 +1,17 @@
+(function () {
+
+    function getLocalMediaSource(serverId, itemId) {
+        var json = ApiClientBridge.getLocalMediaSource(serverId, itemId);
+
+        if (json) {
+            return JSON.parse(json);
+        }
+
+        return null;
+    }
+
+    window.LocalAssetManager = {
+        getLocalMediaSource: getLocalMediaSource
+    };
+
+})();

dashboard-ui/cordova/android/mediasession.js

@@ -0,0 +1,163 @@
+(function () {
+
+    // Reports media playback to the device for lock screen control
+
+    var currentPlayer;
+    var lastPlayerState;
+    var lastUpdateTime = 0;
+
+    function updatePlayerState(state, eventName) {
+
+        if (!state.NowPlayingItem) {
+            hideMediaControls();
+            return;
+        }
+
+        // dummy this up
+        if (eventName == 'init') {
+            eventName = 'positionchange';
+        }
+
+        lastPlayerState = state;
+
+        var playState = state.PlayState || {};
+
+        var nameHtml = MediaController.getNowPlayingNameHtml(state.NowPlayingItem) || '';
+        var parts = nameHtml.split('<br/>');
+
+        var artist = parts.length == 1 ? '' : parts[0];
+        var title = parts[parts.length - 1];
+        var album = state.NowPlayingItem.Album || '';
+        var duration = state.NowPlayingItem.RunTimeTicks ? (state.NowPlayingItem.RunTimeTicks / 10000000) : 0;
+        var position = playState.PositionTicks ? (playState.PositionTicks / 10000000) : 0;
+        var itemId = state.NowPlayingItem.Id;
+
+        var isPaused = playState.IsPaused || false;
+        var canSeek = playState.CanSeek || false;
+
+        var url = '';
+        var imgHeight = 400;
+
+        var nowPlayingItem = state.NowPlayingItem;
+
+        if (nowPlayingItem.PrimaryImageTag) {
+
+            url = ApiClient.getScaledImageUrl(nowPlayingItem.PrimaryImageItemId, {
+                type: "Primary",
+                height: imgHeight,
+                tag: nowPlayingItem.PrimaryImageTag
+            });
+        } else if (nowPlayingItem.ThumbImageTag) {
+
+            url = ApiClient.getScaledImageUrl(nowPlayingItem.ThumbImageItemId, {
+                type: "Thumb",
+                height: imgHeight,
+                tag: nowPlayingItem.ThumbImageTag
+            });
+        }
+        else if (nowPlayingItem.BackdropImageTag) {
+
+            url = ApiClient.getScaledImageUrl(nowPlayingItem.BackdropItemId, {
+                type: "Backdrop",
+                height: imgHeight,
+                tag: nowPlayingItem.BackdropImageTag,
+                index: 0
+            });
+
+        }
+
+        // Don't go crazy reporting position changes
+        if (eventName == 'positionchange') {
+            if (lastUpdateTime) {
+                // Only report if this item hasn't been reported yet, or if there's an actual playback change.
+                // Don't report on simple time updates
+                return;
+            }
+        }
+
+        var isLocalPlayer = MediaController.getPlayerInfo().isLocalPlayer || false;
+
+        MainActivity.updateMediaSession(eventName, isLocalPlayer, itemId, title, artist, album, parseInt(duration), parseInt(position), url, canSeek, isPaused);
+        lastUpdateTime = new Date().getTime();
+    }
+
+    function onStateChanged(e, state) {
+
+        updatePlayerState(state, e.type);
+    }
+
+    function onPlaybackStart(e, state) {
+
+        console.log('nowplaying event: ' + e.type);
+
+        var player = this;
+
+        player.beginPlayerUpdates();
+
+        onStateChanged.call(player, e, state);
+    }
+
+    function onPlaybackStopped(e, state) {
+
+        console.log('nowplaying event: ' + e.type);
+        var player = this;
+
+        player.endPlayerUpdates();
+
+        hideMediaControls();
+    }
+
+    function releaseCurrentPlayer() {
+
+        if (currentPlayer) {
+
+            $(currentPlayer).off('.cordovaremote');
+            currentPlayer.endPlayerUpdates();
+            currentPlayer = null;
+
+            hideMediaControls();
+        }
+    }
+
+    function hideMediaControls() {
+        MainActivity.hideMediaSession();
+        lastUpdateTime = 0;
+    }
+
+    function bindToPlayer(player) {
+
+        releaseCurrentPlayer();
+
+        currentPlayer = player;
+
+        console.log('binding remotecontrols to MediaPlayer');
+
+        player.getPlayerState().done(function (state) {
+
+            if (state.NowPlayingItem) {
+                player.beginPlayerUpdates();
+            }
+
+            onStateChanged.call(player, { type: 'init' }, state);
+        });
+
+        $(player).on('playbackstart.cordovaremote', onPlaybackStart)
+            .on('playbackstop.cordovaremote', onPlaybackStopped)
+            .on('playstatechange.cordovaremote', onStateChanged)
+            .on('positionchange.cordovaremote', onStateChanged);
+    }
+
+    Dashboard.ready(function () {
+
+        console.log('binding remotecontrols to MediaController');
+
+        $(MediaController).on('playerchange', function () {
+
+            bindToPlayer(MediaController.getCurrentPlayer());
+        });
+
+        bindToPlayer(MediaController.getCurrentPlayer());
+
+    });
+
+})();

dashboard-ui/cordova/android/nativedirectorychooser.js

@@ -0,0 +1,31 @@
+(function () {
+
+    var currentDeferred;
+    function chooseDirectory() {
+        var deferred = DeferredBuilder.Deferred();
+        AndroidDirectoryChooser.chooseDirectory();
+        currentDeferred = deferred;
+        return deferred.promise();
+    }
+
+    function onChosen(path) {
+
+        var deferred = currentDeferred;
+
+        if (deferred) {
+            if (path) {
+                deferred.resolveWith(null, [path]);
+            } else {
+                deferred.reject();
+            }
+
+            currentDeferred = null;
+        }
+    }
+
+    window.NativeDirectoryChooser = {
+        chooseDirectory: chooseDirectory,
+        onChosen: onChosen
+    };
+
+})();

dashboard-ui/cordova/android/vlcplayer.js

@@ -0,0 +1,165 @@
+(function () {
+
+    function vlcRenderer(type) {
+
+        var self = this;
+
+        function onEnded() {
+            $(self).trigger('ended');
+        }
+
+        function onTimeUpdate() {
+            $(self).trigger('timeupdate');
+        }
+
+        function onVolumeChange() {
+            $(self).trigger('volumechange');
+        }
+
+        function onPlaying() {
+            $(self).trigger('playing');
+        }
+
+        function onPlay() {
+            $(self).trigger('play');
+        }
+
+        function onPause() {
+            $(self).trigger('pause');
+        }
+
+        function onClick() {
+            $(self).trigger('click');
+        }
+
+        function onDblClick() {
+            $(self).trigger('dblclick');
+        }
+
+        function onError() {
+
+            var errorCode = this.error ? this.error.code : '';
+            console.log('Media element error code: ' + errorCode);
+
+            $(self).trigger('error');
+        }
+
+        var playerState = {};
+
+        self.currentTime = function (val) {
+
+            if (val != null) {
+                AndroidVlcPlayer.sendVlcCommand("setposition", val.toString());
+                return;
+            }
+
+            return playerState.currentTime;
+        };
+
+        self.duration = function (val) {
+
+            if (playerState) {
+                return playerState.duration;
+            }
+
+            return null;
+        };
+
+        self.stop = function () {
+            AndroidVlcPlayer.sendVlcCommand("stop", null);
+        };
+
+        self.pause = function () {
+            AndroidVlcPlayer.sendVlcCommand("pause", null);
+        };
+
+        self.unpause = function () {
+            AndroidVlcPlayer.sendVlcCommand("unpause", null);
+        };
+
+        self.volume = function (val) {
+            if (playerState) {
+                if (val != null) {
+                    AndroidVlcPlayer.sendVlcCommand("setvolume", (val * 100).toString());
+                    return;
+                }
+
+                return playerState.volume;
+            }
+        };
+
+        self.setCurrentSrc = function (val) {
+
+            if (!val) {
+                self.destroy();
+                return;
+            }
+
+            if (type == 'audio') {
+                AndroidVlcPlayer.playAudioVlc(val);
+            } else {
+                AndroidVlcPlayer.playVideoVlc(val);
+            }
+
+            playerState.currentSrc = val;
+        };
+
+        self.currentSrc = function () {
+            if (playerState) {
+                return playerState.currentSrc;
+            }
+        };
+
+        self.paused = function () {
+
+            if (playerState) {
+                return playerState.paused;
+            }
+
+            return false;
+        };
+
+        self.destroy = function () {
+
+            AndroidVlcPlayer.destroyVlc();
+            playerState = {};
+        };
+
+        self.setPoster = function (url) {
+        };
+
+        self.report = function (eventName, duration, position, isPaused, volume) {
+
+            var state = playerState;
+
+            state.duration = duration;
+            state.currentTime = position;
+            state.paused = isPaused;
+            state.volume = (volume || 0) / 100;
+
+            if (eventName == 'playbackstop') {
+                onEnded();
+            }
+            else if (eventName == 'volumechange') {
+                onVolumeChange();
+            }
+            else if (eventName == 'positionchange') {
+                onTimeUpdate();
+            }
+            else if (eventName == 'paused') {
+                onPause();
+            }
+            else if (eventName == 'unpaused') {
+                onPlaying();
+            }
+            else if (eventName == 'playing') {
+                onPlaying();
+            }
+        };
+
+        window.AudioRenderer.Current = self;
+    }
+
+    window.AudioRenderer = vlcRenderer;
+
+})();