First separation commit.

Added LICENSE, README.md, CONTRIBUTORS.md

src/bower_components/emby-apiclient/sync/contentuploader.js

@@ -0,0 +1,57 @@
+define(["localassetmanager", "cameraRoll"], function(localAssetManager, cameraRoll) {
+    "use strict";
+
+    function getFilesToUpload(files, uploadHistory) {
+        return files.filter(function(file) {
+            if (!file) return !1;
+            var uploadId = getUploadId(file);
+            return 0 === uploadHistory.FilesUploaded.filter(function(u) {
+                return uploadId === u.Id
+            }).length
+        })
+    }
+
+    function getUploadId(file) {
+        return btoa(file.Id + "1")
+    }
+
+    function uploadNext(files, index, server, apiClient, resolve, reject) {
+        var length = files.length;
+        if (index >= length) return void resolve();
+        uploadFile(files[index], apiClient).then(function() {
+            uploadNext(files, index + 1, server, apiClient, resolve, reject)
+        }, function() {
+            uploadNext(files, index + 1, server, apiClient, resolve, reject)
+        })
+    }
+
+    function uploadFile(file, apiClient) {
+        return new Promise(function(resolve, reject) {
+            require(["fileupload"], function(FileUpload) {
+                var url = apiClient.getUrl("Devices/CameraUploads", {
+                    DeviceId: apiClient.deviceId(),
+                    Name: file.Name,
+                    Album: "Camera Roll",
+                    Id: getUploadId(file),
+                    api_key: apiClient.accessToken()
+                });
+                console.log("Uploading file to " + url), (new FileUpload).upload(file, url).then(resolve, reject)
+            })
+        })
+    }
+
+    function ContentUploader() {}
+    return ContentUploader.prototype.uploadImages = function(connectionManager, server) {
+        return cameraRoll.getFiles().then(function(photos) {
+            if (!photos.length) return Promise.resolve();
+            var apiClient = connectionManager.getApiClient(server.Id);
+            return apiClient.getContentUploadHistory().then(function(uploadHistory) {
+                return photos = getFilesToUpload(photos, uploadHistory), console.log("Found " + photos.length + " files to upload"), new Promise(function(resolve, reject) {
+                    uploadNext(photos, 0, server, apiClient, resolve, reject)
+                })
+            }, function() {
+                return Promise.resolve()
+            })
+        })
+    }, ContentUploader
+});

src/bower_components/emby-apiclient/sync/filerepository.js

@@ -0,0 +1,45 @@
+define([], function() {
+    "use strict";
+
+    function getValidFileName(path) {
+        return path
+    }
+
+    function getFullLocalPath(pathArray) {
+        return pathArray.join("/")
+    }
+
+    function getPathFromArray(pathArray) {
+        return pathArray.join("/")
+    }
+
+    function deleteFile(path) {
+        return Promise.resolve()
+    }
+
+    function deleteDirectory(path) {
+        return Promise.resolve()
+    }
+
+    function fileExists(path) {
+        return Promise.resolve()
+    }
+
+    function getItemFileSize(path) {
+        return Promise.resolve(0)
+    }
+
+    function getImageUrl(pathParts) {
+        return pathParts.join("/")
+    }
+    return {
+        getValidFileName: getValidFileName,
+        getFullLocalPath: getFullLocalPath,
+        getPathFromArray: getPathFromArray,
+        deleteFile: deleteFile,
+        deleteDirectory: deleteDirectory,
+        fileExists: fileExists,
+        getItemFileSize: getItemFileSize,
+        getImageUrl: getImageUrl
+    }
+});

src/bower_components/emby-apiclient/sync/itemrepository.js

@@ -0,0 +1,123 @@
+define([], function() {
+    "use strict";
+
+    function ServerDatabase(dbName, readyCallback) {
+        var request = indexedDB.open(dbName, dbVersion);
+        request.onerror = function(event) {}, request.onupgradeneeded = function(event) {
+            var db = event.target.result;
+            db.createObjectStore(dbName).transaction.oncomplete = function(event) {
+                readyCallback(db)
+            }
+        }, request.onsuccess = function(event) {
+            var db = event.target.result;
+            readyCallback(db)
+        }
+    }
+
+    function getDbName(serverId) {
+        return "items_" + serverId
+    }
+
+    function getDb(serverId, callback) {
+        var dbName = getDbName(serverId),
+            db = databases[dbName];
+        if (db) return void callback(db);
+        new ServerDatabase(dbName, function(db) {
+            databases[dbName] = db, callback(db)
+        })
+    }
+
+    function getServerItemTypes(serverId, userId) {
+        return getAll(serverId, userId).then(function(all) {
+            return all.map(function(item2) {
+                return item2.Item.Type || ""
+            }).filter(filterDistinct)
+        })
+    }
+
+    function getAll(serverId, userId) {
+        return new Promise(function(resolve, reject) {
+            getDb(serverId, function(db) {
+                var request, storeName = getDbName(serverId),
+                    transaction = db.transaction([storeName], "readonly"),
+                    objectStore = transaction.objectStore(storeName);
+                if ("getAll" in objectStore) request = objectStore.getAll(null, 1e4), request.onsuccess = function(event) {
+                    resolve(event.target.result)
+                };
+                else {
+                    var results = [];
+                    request = objectStore.openCursor(), request.onsuccess = function(event) {
+                        var cursor = event.target.result;
+                        cursor ? (results.push(cursor.value), cursor.continue()) : resolve(results)
+                    }
+                }
+                request.onerror = reject
+            })
+        })
+    }
+
+    function get(serverId, key) {
+        return new Promise(function(resolve, reject) {
+            getDb(serverId, function(db) {
+                var storeName = getDbName(serverId),
+                    transaction = db.transaction([storeName], "readonly"),
+                    objectStore = transaction.objectStore(storeName),
+                    request = objectStore.get(key);
+                request.onerror = reject, request.onsuccess = function(event) {
+                    resolve(request.result)
+                }
+            })
+        })
+    }
+
+    function set(serverId, key, val) {
+        return new Promise(function(resolve, reject) {
+            getDb(serverId, function(db) {
+                var storeName = getDbName(serverId),
+                    transaction = db.transaction([storeName], "readwrite"),
+                    objectStore = transaction.objectStore(storeName),
+                    request = objectStore.put(val, key);
+                request.onerror = reject, request.onsuccess = resolve
+            })
+        })
+    }
+
+    function remove(serverId, key) {
+        return new Promise(function(resolve, reject) {
+            getDb(serverId, function(db) {
+                var storeName = getDbName(serverId),
+                    transaction = db.transaction([storeName], "readwrite"),
+                    objectStore = transaction.objectStore(storeName),
+                    request = objectStore.delete(key);
+                request.onerror = reject, request.onsuccess = resolve
+            })
+        })
+    }
+
+    function clear(serverId) {
+        return new Promise(function(resolve, reject) {
+            getDb(serverId, function(db) {
+                var storeName = getDbName(serverId),
+                    transaction = db.transaction([storeName], "readwrite"),
+                    objectStore = transaction.objectStore(storeName),
+                    request = objectStore.clear();
+                request.onerror = reject, request.onsuccess = resolve
+            })
+        })
+    }
+
+    function filterDistinct(value, index, self) {
+        return self.indexOf(value) === index
+    }
+    var indexedDB = self.indexedDB || self.mozIndexedDB || self.webkitIndexedDB || self.msIndexedDB,
+        dbVersion = (self.IDBTransaction || self.webkitIDBTransaction || self.msIDBTransaction, self.IDBKeyRange || self.webkitIDBKeyRange || self.msIDBKeyRange, 1),
+        databases = {};
+    return {
+        get: get,
+        set: set,
+        remove: remove,
+        clear: clear,
+        getAll: getAll,
+        getServerItemTypes: getServerItemTypes
+    }
+});

src/bower_components/emby-apiclient/sync/localsync.js

@@ -0,0 +1,17 @@
+define(["connectionManager"], function(connectionManager) {
+    "use strict";
+    var isSyncing;
+    return {
+        sync: function(options) {
+            return console.log("localSync.sync starting..."), isSyncing ? Promise.resolve() : (isSyncing = !0, new Promise(function(resolve, reject) {
+                require(["multiserversync", "appSettings"], function(MultiServerSync, appSettings) {
+                    options = options || {}, options.cameraUploadServers = appSettings.cameraUploadServers(), (new MultiServerSync).sync(connectionManager, options).then(function() {
+                        isSyncing = null, resolve()
+                    }, function(err) {
+                        isSyncing = null, reject(err)
+                    })
+                })
+            }))
+        }
+    }
+});

src/bower_components/emby-apiclient/sync/mediasync.js

@@ -0,0 +1,368 @@
+define(["localassetmanager"], function(localassetmanager) {
+    "use strict";
+
+    function processDownloadStatus(apiClient, serverInfo, options) {
+        return console.log("[mediasync] Begin processDownloadStatus"), localassetmanager.resyncTransfers().then(function() {
+            return localassetmanager.getServerItems(serverInfo.Id).then(function(items) {
+                console.log("[mediasync] Begin processDownloadStatus getServerItems completed");
+                var p = Promise.resolve(),
+                    cnt = 0;
+                return items.filter(function(item) {
+                    return "transferring" === item.SyncStatus || "queued" === item.SyncStatus
+                }).forEach(function(item) {
+                    p = p.then(function() {
+                        return reportTransfer(apiClient, item)
+                    }), cnt++
+                }), p.then(function() {
+                    return console.log("[mediasync] Exit processDownloadStatus. Items reported: " + cnt.toString()), Promise.resolve()
+                })
+            })
+        })
+    }
+
+    function reportTransfer(apiClient, item) {
+        return localassetmanager.getItemFileSize(item.LocalPath).then(function(size) {
+            return size > 0 ? apiClient.reportSyncJobItemTransferred(item.SyncJobItemId).then(function() {
+                return item.SyncStatus = "synced", console.log("[mediasync] reportSyncJobItemTransferred called for " + item.LocalPath), localassetmanager.addOrUpdateLocalItem(item)
+            }, function(error) {
+                return console.error("[mediasync] Mediasync error on reportSyncJobItemTransferred", error), item.SyncStatus = "error", localassetmanager.addOrUpdateLocalItem(item)
+            }) : localassetmanager.isDownloadFileInQueue(item.LocalPath).then(function(result) {
+                return result ? Promise.resolve() : (console.log("[mediasync] reportTransfer: Size is 0 and download no longer in queue. Deleting item."), localassetmanager.removeLocalItem(item).then(function() {
+                    return console.log("[mediasync] reportTransfer: Item deleted."), Promise.resolve()
+                }, function(err2) {
+                    return console.log("[mediasync] reportTransfer: Failed to delete item.", err2), Promise.resolve()
+                }))
+            })
+        }, function(error) {
+            return console.error("[mediasync] reportTransfer: error on getItemFileSize. Deleting item.", error), localassetmanager.removeLocalItem(item).then(function() {
+                return console.log("[mediasync] reportTransfer: Item deleted."), Promise.resolve()
+            }, function(err2) {
+                return console.log("[mediasync] reportTransfer: Failed to delete item.", err2), Promise.resolve()
+            })
+        })
+    }
+
+    function reportOfflineActions(apiClient, serverInfo) {
+        return console.log("[mediasync] Begin reportOfflineActions"), localassetmanager.getUserActions(serverInfo.Id).then(function(actions) {
+            return actions.length ? apiClient.reportOfflineActions(actions).then(function() {
+                return localassetmanager.deleteUserActions(actions).then(function() {
+                    return console.log("[mediasync] Exit reportOfflineActions (actions reported and deleted.)"), Promise.resolve()
+                })
+            }, function(err) {
+                return console.error("[mediasync] error on apiClient.reportOfflineActions: " + err.toString()), localassetmanager.deleteUserActions(actions)
+            }) : (console.log("[mediasync] Exit reportOfflineActions (no actions)"), Promise.resolve())
+        })
+    }
+
+    function syncData(apiClient, serverInfo) {
+        return console.log("[mediasync] Begin syncData"), localassetmanager.getServerItems(serverInfo.Id).then(function(items) {
+            var completedItems = items.filter(function(item) {
+                    return item && ("synced" === item.SyncStatus || "error" === item.SyncStatus)
+                }),
+                request = {
+                    TargetId: apiClient.deviceId(),
+                    LocalItemIds: completedItems.map(function(xitem) {
+                        return xitem.ItemId
+                    })
+                };
+            return apiClient.syncData(request).then(function(result) {
+                return afterSyncData(apiClient, serverInfo, result).then(function() {
+                    return console.log("[mediasync] Exit syncData"), Promise.resolve()
+                }, function(err) {
+                    return console.error("[mediasync] Error in syncData: " + err.toString()), Promise.resolve()
+                })
+            })
+        })
+    }
+
+    function afterSyncData(apiClient, serverInfo, syncDataResult) {
+        console.log("[mediasync] Begin afterSyncData");
+        var p = Promise.resolve();
+        return syncDataResult.ItemIdsToRemove && syncDataResult.ItemIdsToRemove.length > 0 && syncDataResult.ItemIdsToRemove.forEach(function(itemId) {
+            p = p.then(function() {
+                return removeLocalItem(itemId, serverInfo.Id)
+            })
+        }), p = p.then(function() {
+            return removeObsoleteContainerItems(serverInfo.Id)
+        }), p.then(function() {
+            return console.log("[mediasync] Exit afterSyncData"), Promise.resolve()
+        })
+    }
+
+    function removeObsoleteContainerItems(serverId) {
+        return console.log("[mediasync] Begin removeObsoleteContainerItems"), localassetmanager.removeObsoleteContainerItems(serverId)
+    }
+
+    function removeLocalItem(itemId, serverId) {
+        return console.log("[mediasync] Begin removeLocalItem"), localassetmanager.getLocalItem(serverId, itemId).then(function(item) {
+            return item ? localassetmanager.removeLocalItem(item) : Promise.resolve()
+        }, function(err2) {
+            return console.error("[mediasync] removeLocalItem: Failed: ", err2), Promise.resolve()
+        })
+    }
+
+    function getNewMedia(apiClient, downloadCount) {
+        return console.log("[mediasync] Begin getNewMedia"), apiClient.getReadySyncItems(apiClient.deviceId()).then(function(jobItems) {
+            console.log("[mediasync] getReadySyncItems returned " + jobItems.length + " items");
+            var p = Promise.resolve(),
+                currentCount = downloadCount;
+            return jobItems.forEach(function(jobItem) {
+                currentCount++ <= 10 && (p = p.then(function() {
+                    return getNewItem(jobItem, apiClient)
+                }))
+            }), p.then(function() {
+                return console.log("[mediasync] Exit getNewMedia"), Promise.resolve()
+            })
+        }, function(err) {
+            return console.error("[mediasync] getReadySyncItems: Failed: ", err), Promise.resolve()
+        })
+    }
+
+    function afterMediaDownloaded(apiClient, jobItem, localItem) {
+        return console.log("[mediasync] Begin afterMediaDownloaded"), getImages(apiClient, jobItem, localItem).then(function() {
+            var libraryItem = jobItem.Item;
+            return downloadParentItems(apiClient, jobItem, libraryItem).then(function() {
+                return getSubtitles(apiClient, jobItem, localItem)
+            })
+        })
+    }
+
+    function createLocalItem(libraryItem, jobItem) {
+        console.log("[localassetmanager] Begin createLocalItem");
+        var item = {
+            Item: libraryItem,
+            ItemId: libraryItem.Id,
+            ServerId: libraryItem.ServerId,
+            Id: libraryItem.Id
+        };
+        return jobItem && (item.SyncJobItemId = jobItem.SyncJobItemId), console.log("[localassetmanager] End createLocalItem"), item
+    }
+
+    function getNewItem(jobItem, apiClient) {
+        console.log("[mediasync] Begin getNewItem");
+        var libraryItem = jobItem.Item;
+        return localassetmanager.getLocalItem(libraryItem.ServerId, libraryItem.Id).then(function(existingItem) {
+            if (existingItem && ("queued" === existingItem.SyncStatus || "transferring" === existingItem.SyncStatus || "synced" === existingItem.SyncStatus) && (console.log("[mediasync] getNewItem: getLocalItem found existing item"), localassetmanager.enableBackgroundCompletion())) return Promise.resolve();
+            libraryItem.CanDelete = !1, libraryItem.CanDownload = !1, libraryItem.SupportsSync = !1, libraryItem.People = [], libraryItem.Chapters = [], libraryItem.Studios = [], libraryItem.SpecialFeatureCount = null, libraryItem.LocalTrailerCount = null, libraryItem.RemoteTrailers = [];
+            var localItem = createLocalItem(libraryItem, jobItem);
+            return localItem.SyncStatus = "queued", downloadMedia(apiClient, jobItem, localItem)
+        })
+    }
+
+    function downloadParentItems(apiClient, jobItem, libraryItem) {
+        var p = Promise.resolve();
+        return libraryItem.SeriesId && (p = p.then(function() {
+            return downloadItem(apiClient, libraryItem.SeriesId)
+        })), libraryItem.SeasonId && (p = p.then(function() {
+            return downloadItem(apiClient, libraryItem.SeasonId).then(function(seasonItem) {
+                return libraryItem.SeasonPrimaryImageTag = (seasonItem.Item.ImageTags || {}).Primary, Promise.resolve()
+            })
+        })), libraryItem.AlbumId && (p = p.then(function() {
+            return downloadItem(apiClient, libraryItem.AlbumId)
+        })), p
+    }
+
+    function downloadItem(apiClient, itemId) {
+        return apiClient.getItem(apiClient.getCurrentUserId(), itemId).then(function(downloadedItem) {
+            downloadedItem.CanDelete = !1, downloadedItem.CanDownload = !1, downloadedItem.SupportsSync = !1, downloadedItem.People = [], downloadedItem.SpecialFeatureCount = null, downloadedItem.BackdropImageTags = null, downloadedItem.ParentBackdropImageTags = null, downloadedItem.ParentArtImageTag = null, downloadedItem.ParentLogoImageTag = null;
+            var localItem = createLocalItem(downloadedItem, null);
+            return localassetmanager.addOrUpdateLocalItem(localItem).then(function() {
+                return Promise.resolve(localItem)
+            }, function(err) {
+                return console.error("[mediasync] downloadItem failed: " + err.toString()), Promise.resolve(null)
+            })
+        })
+    }
+
+    function ensureLocalPathParts(localItem, jobItem) {
+        if (!localItem.LocalPathParts) {
+            var libraryItem = localItem.Item,
+                parts = localassetmanager.getDirectoryPath(libraryItem);
+            parts.push(localassetmanager.getLocalFileName(libraryItem, jobItem.OriginalFileName)), localItem.LocalPathParts = parts
+        }
+    }
+
+    function downloadMedia(apiClient, jobItem, localItem) {
+        console.log("[mediasync] downloadMedia: start.");
+        var url = apiClient.getUrl("Sync/JobItems/" + jobItem.SyncJobItemId + "/File", {
+            api_key: apiClient.accessToken()
+        });
+        return ensureLocalPathParts(localItem, jobItem), localassetmanager.downloadFile(url, localItem).then(function(result) {
+            console.log("[mediasync] downloadMedia-downloadFile returned path: " + result.path);
+            var localPath = result.path,
+                libraryItem = localItem.Item;
+            if (localPath && libraryItem.MediaSources)
+                for (var i = 0; i < libraryItem.MediaSources.length; i++) {
+                    var mediaSource = libraryItem.MediaSources[i];
+                    mediaSource.Path = localPath, mediaSource.Protocol = "File"
+                }
+            return localItem.LocalPath = localPath, localItem.SyncStatus = "transferring", localassetmanager.addOrUpdateLocalItem(localItem).then(function() {
+                return afterMediaDownloaded(apiClient, jobItem, localItem).then(function() {
+                    return result.isComplete ? (localItem.SyncStatus = "synced", reportTransfer(apiClient, localItem)) : Promise.resolve()
+                }, function(err) {
+                    return console.log("[mediasync] downloadMedia: afterMediaDownloaded failed: " + err), Promise.reject(err)
+                })
+            }, function(err) {
+                return console.log("[mediasync] downloadMedia: addOrUpdateLocalItem failed: " + err), Promise.reject(err)
+            })
+        }, function(err) {
+            return console.log("[mediasync] downloadMedia: localassetmanager.downloadFile failed: " + err), Promise.reject(err)
+        })
+    }
+
+    function getImages(apiClient, jobItem, localItem) {
+        console.log("[mediasync] Begin getImages");
+        var p = Promise.resolve(),
+            libraryItem = localItem.Item,
+            serverId = libraryItem.ServerId,
+            mainImageTag = (libraryItem.ImageTags || {}).Primary;
+        libraryItem.Id && mainImageTag && (p = p.then(function() {
+            return downloadImage(localItem, apiClient, serverId, libraryItem.Id, mainImageTag, "Primary")
+        }));
+        var logoImageTag = (libraryItem.ImageTags || {}).Logo;
+        libraryItem.Id && logoImageTag && (p = p.then(function() {
+            return downloadImage(localItem, apiClient, serverId, libraryItem.Id, logoImageTag, "Logo")
+        }));
+        var artImageTag = (libraryItem.ImageTags || {}).Art;
+        libraryItem.Id && artImageTag && (p = p.then(function() {
+            return downloadImage(localItem, apiClient, serverId, libraryItem.Id, artImageTag, "Art")
+        }));
+        var bannerImageTag = (libraryItem.ImageTags || {}).Banner;
+        libraryItem.Id && bannerImageTag && (p = p.then(function() {
+            return downloadImage(localItem, apiClient, serverId, libraryItem.Id, bannerImageTag, "Banner")
+        }));
+        var thumbImageTag = (libraryItem.ImageTags || {}).Thumb;
+        if (libraryItem.Id && thumbImageTag && (p = p.then(function() {
+                return downloadImage(localItem, apiClient, serverId, libraryItem.Id, thumbImageTag, "Thumb")
+            })), libraryItem.Id && libraryItem.BackdropImageTags)
+            for (var i = 0; i < libraryItem.BackdropImageTags.length; i++);
+        return libraryItem.SeriesId && libraryItem.SeriesPrimaryImageTag && (p = p.then(function() {
+            return downloadImage(localItem, apiClient, serverId, libraryItem.SeriesId, libraryItem.SeriesPrimaryImageTag, "Primary")
+        })), libraryItem.SeriesId && libraryItem.SeriesThumbImageTag && (p = p.then(function() {
+            return downloadImage(localItem, apiClient, serverId, libraryItem.SeriesId, libraryItem.SeriesThumbImageTag, "Thumb")
+        })), libraryItem.SeasonId && libraryItem.SeasonPrimaryImageTag && (p = p.then(function() {
+            return downloadImage(localItem, apiClient, serverId, libraryItem.SeasonId, libraryItem.SeasonPrimaryImageTag, "Primary")
+        })), libraryItem.AlbumId && libraryItem.AlbumPrimaryImageTag && (p = p.then(function() {
+            return downloadImage(localItem, apiClient, serverId, libraryItem.AlbumId, libraryItem.AlbumPrimaryImageTag, "Primary")
+        })), libraryItem.ParentThumbItemId && libraryItem.ParentThumbImageTag && (p = p.then(function() {
+            return downloadImage(localItem, apiClient, serverId, libraryItem.ParentThumbItemId, libraryItem.ParentThumbImageTag, "Thumb")
+        })), libraryItem.ParentPrimaryImageItemId && libraryItem.ParentPrimaryImageTag && (p = p.then(function() {
+            return downloadImage(localItem, apiClient, serverId, libraryItem.ParentPrimaryImageItemId, libraryItem.ParentPrimaryImageTag, "Primary")
+        })), p.then(function() {
+            return console.log("[mediasync] Finished getImages"), localassetmanager.addOrUpdateLocalItem(localItem)
+        }, function(err) {
+            return console.log("[mediasync] Error getImages: " + err.toString()), Promise.resolve()
+        })
+    }
+
+    function downloadImage(localItem, apiClient, serverId, itemId, imageTag, imageType, index) {
+        return index = index || 0, localassetmanager.hasImage(serverId, itemId, imageType, index).then(function(hasImage) {
+            if (hasImage) return console.log("[mediasync] downloadImage - skip existing: " + itemId + " " + imageType + "_" + index.toString()), Promise.resolve();
+            var maxWidth = 400;
+            "backdrop" === imageType && (maxWidth = null);
+            var imageUrl = apiClient.getScaledImageUrl(itemId, {
+                tag: imageTag,
+                type: imageType,
+                maxWidth: maxWidth,
+                api_key: apiClient.accessToken()
+            });
+            return console.log("[mediasync] downloadImage " + itemId + " " + imageType + "_" + index.toString()), localassetmanager.downloadImage(localItem, imageUrl, serverId, itemId, imageType, index).then(function(result) {
+                return Promise.resolve(result)
+            }, function(err) {
+                return console.log("[mediasync] Error downloadImage: " + err.toString()), Promise.resolve()
+            })
+        }, function(err) {
+            return console.log("[mediasync] Error downloadImage: " + err.toString()), Promise.resolve()
+        })
+    }
+
+    function getSubtitles(apiClient, jobItem, localItem) {
+        if (console.log("[mediasync] Begin getSubtitles"), !jobItem.Item.MediaSources.length) return console.log("[mediasync] Cannot download subtitles because video has no media source info."), Promise.resolve();
+        var files = jobItem.AdditionalFiles.filter(function(f) {
+                return "Subtitles" === f.Type
+            }),
+            mediaSource = jobItem.Item.MediaSources[0],
+            p = Promise.resolve();
+        return files.forEach(function(file) {
+            p = p.then(function() {
+                return getItemSubtitle(file, apiClient, jobItem, localItem, mediaSource)
+            })
+        }), p.then(function() {
+            return console.log("[mediasync] Exit getSubtitles"), Promise.resolve()
+        })
+    }
+
+    function getItemSubtitle(file, apiClient, jobItem, localItem, mediaSource) {
+        console.log("[mediasync] Begin getItemSubtitle");
+        var subtitleStream = mediaSource.MediaStreams.filter(function(m) {
+            return "Subtitle" === m.Type && m.Index === file.Index
+        })[0];
+        if (!subtitleStream) return console.log("[mediasync] Cannot download subtitles because matching stream info was not found."), Promise.resolve();
+        var url = apiClient.getUrl("Sync/JobItems/" + jobItem.SyncJobItemId + "/AdditionalFiles", {
+                Name: file.Name,
+                api_key: apiClient.accessToken()
+            }),
+            fileName = localassetmanager.getSubtitleSaveFileName(localItem, jobItem.OriginalFileName, subtitleStream.Language, subtitleStream.IsForced, subtitleStream.Codec);
+        return localassetmanager.downloadSubtitles(url, fileName).then(function(subtitleResult) {
+            return localItem.AdditionalFiles && localItem.AdditionalFiles.forEach(function(item) {
+                item.Name === file.Name && (item.Path = subtitleResult.path)
+            }), subtitleStream.Path = subtitleResult.path, subtitleStream.DeliveryMethod = "External", localassetmanager.addOrUpdateLocalItem(localItem)
+        })
+    }
+
+    function checkLocalFileExistence(apiClient, serverInfo, options) {
+        return options.checkFileExistence ? (console.log("[mediasync] Begin checkLocalFileExistence"), localassetmanager.getServerItems(serverInfo.Id).then(function(items) {
+            var completedItems = items.filter(function(item) {
+                    return item && ("synced" === item.SyncStatus || "error" === item.SyncStatus)
+                }),
+                p = Promise.resolve();
+            return completedItems.forEach(function(completedItem) {
+                p = p.then(function() {
+                    return localassetmanager.fileExists(completedItem.LocalPath).then(function(exists) {
+                        return exists ? Promise.resolve() : localassetmanager.removeLocalItem(completedItem).then(function() {
+                            return Promise.resolve()
+                        }, function() {
+                            return Promise.resolve()
+                        })
+                    })
+                })
+            }), p
+        })) : Promise.resolve()
+    }
+    return function() {
+        var self = this;
+        "string" == typeof webWorkerBaseUrl && -1 !== webWorkerBaseUrl.indexOf("ms-appx://") ? self.sync = function(apiClient, serverInfo, options) {
+            return console.log("[mediasync]************************************* Start sync"), checkLocalFileExistence(apiClient, serverInfo, options).then(function() {
+                return processDownloadStatus(apiClient, serverInfo, options).then(function() {
+                    return localassetmanager.getDownloadItemCount().then(function(downloadCount) {
+                        return !0 === options.syncCheckProgressOnly && downloadCount > 2 ? Promise.resolve() : reportOfflineActions(apiClient, serverInfo).then(function() {
+                            return getNewMedia(apiClient, downloadCount).then(function() {
+                                return syncData(apiClient, serverInfo).then(function() {
+                                    return console.log("[mediasync]************************************* Exit sync"), Promise.resolve()
+                                })
+                            })
+                        })
+                    })
+                })
+            }, function(err) {
+                console.error(err.toString())
+            })
+        } : self.sync = function(apiClient, serverInfo, options) {
+            return console.log("[mediasync]************************************* Start sync"), checkLocalFileExistence(apiClient, serverInfo, options).then(function() {
+                return syncData(apiClient, serverInfo).then(function() {
+                    return processDownloadStatus(apiClient, serverInfo, options).then(function() {
+                        return localassetmanager.getDownloadItemCount().then(function(downloadCount) {
+                            return !0 === options.syncCheckProgressOnly && downloadCount > 2 ? Promise.resolve() : reportOfflineActions(apiClient, serverInfo).then(function() {
+                                return getNewMedia(apiClient, downloadCount).then(function() {
+                                    return syncData(apiClient, serverInfo)
+                                })
+                            })
+                        })
+                    })
+                })
+            }, function(err) {
+                console.error(err.toString())
+            })
+        }
+    }
+});

src/bower_components/emby-apiclient/sync/multiserversync.js

@@ -0,0 +1,22 @@
+define(["serversync"], function(ServerSync) {
+    "use strict";
+
+    function syncNext(connectionManager, servers, index, options, resolve, reject) {
+        var length = servers.length;
+        if (index >= length) return console.log("MultiServerSync.sync complete"), void resolve();
+        var server = servers[index];
+        console.log("Creating ServerSync to server: " + server.Id), (new ServerSync).sync(connectionManager, server, options).then(function() {
+            console.log("ServerSync succeeded to server: " + server.Id), syncNext(connectionManager, servers, index + 1, options, resolve, reject)
+        }, function(err) {
+            console.log("ServerSync failed to server: " + server.Id + ". " + err), syncNext(connectionManager, servers, index + 1, options, resolve, reject)
+        })
+    }
+
+    function MultiServerSync() {}
+    return MultiServerSync.prototype.sync = function(connectionManager, options) {
+        return console.log("MultiServerSync.sync starting..."), new Promise(function(resolve, reject) {
+            var servers = connectionManager.getSavedServers();
+            syncNext(connectionManager, servers, 0, options, resolve, reject)
+        })
+    }, MultiServerSync
+});

src/bower_components/emby-apiclient/sync/serversync.js

@@ -0,0 +1,46 @@
+define([], function() {
+    "use strict";
+
+    function performSync(connectionManager, server, options) {
+        console.log("ServerSync.performSync to server: " + server.Id), options = options || {};
+        var cameraUploadServers = options.cameraUploadServers || [];
+        console.log("ServerSync cameraUploadServers: " + JSON.stringify(cameraUploadServers));
+        var uploadPhotos = -1 !== cameraUploadServers.indexOf(server.Id);
+        return console.log("ServerSync uploadPhotos: " + uploadPhotos), (uploadPhotos ? uploadContent(connectionManager, server, options) : Promise.resolve()).then(function() {
+            return syncMedia(connectionManager, server, options)
+        })
+    }
+
+    function uploadContent(connectionManager, server, options) {
+        return new Promise(function(resolve, reject) {
+            require(["contentuploader"], function(ContentUploader) {
+                (new ContentUploader).uploadImages(connectionManager, server).then(resolve, reject)
+            })
+        })
+    }
+
+    function syncMedia(connectionManager, server, options) {
+        return new Promise(function(resolve, reject) {
+            require(["mediasync"], function(MediaSync) {
+                var apiClient = connectionManager.getApiClient(server.Id);
+                (new MediaSync).sync(apiClient, server, options).then(resolve, reject)
+            })
+        })
+    }
+
+    function ServerSync() {}
+    return ServerSync.prototype.sync = function(connectionManager, server, options) {
+        if (!server.AccessToken && !server.ExchangeToken) return console.log("Skipping sync to server " + server.Id + " because there is no saved authentication information."), Promise.resolve();
+        var connectionOptions = {
+            updateDateLastAccessed: !1,
+            enableWebSocket: !1,
+            reportCapabilities: !1,
+            enableAutomaticBitrateDetection: !1
+        };
+        return connectionManager.connectToServer(server, connectionOptions).then(function(result) {
+            return "SignedIn" === result.State ? performSync(connectionManager, server, options) : (console.log("Unable to connect to server id: " + server.Id), Promise.reject())
+        }, function(err) {
+            throw console.log("Unable to connect to server id: " + server.Id), err
+        })
+    }, ServerSync
+});

src/bower_components/emby-apiclient/sync/transfermanager.js

@@ -0,0 +1,30 @@
+define([], function() {
+    "use strict";
+
+    function downloadFile(url, folder, localItem, imageUrl) {
+        return Promise.reject()
+    }
+
+    function downloadSubtitles(url, folder, fileName) {
+        return Promise.reject()
+    }
+
+    function downloadImage(url, folder, fileName) {
+        return Promise.reject()
+    }
+
+    function resyncTransfers() {
+        return Promise.resolve()
+    }
+
+    function getDownloadItemCount() {
+        return Promise.resolve(0)
+    }
+    return {
+        downloadFile: downloadFile,
+        downloadSubtitles: downloadSubtitles,
+        downloadImage: downloadImage,
+        resyncTransfers: resyncTransfers,
+        getDownloadItemCount: getDownloadItemCount
+    }
+});

src/bower_components/emby-apiclient/sync/useractionrepository.js

@@ -0,0 +1,108 @@
+define([], function() {
+    "use strict";
+
+    function getDb(callback) {
+        var db = databaseInstance;
+        if (db) return void callback(db);
+        var request = indexedDB.open(dbName, dbVersion);
+        request.onerror = function(event) {}, request.onupgradeneeded = function(event) {
+            var db = event.target.result;
+            db.createObjectStore(dbName).transaction.oncomplete = function(event) {
+                callback(db)
+            }
+        }, request.onsuccess = function(event) {
+            var db = event.target.result;
+            callback(db)
+        }
+    }
+
+    function getByServerId(serverId) {
+        return getAll().then(function(items) {
+            return items.filter(function(item) {
+                return item.ServerId === serverId
+            })
+        })
+    }
+
+    function getAll() {
+        return new Promise(function(resolve, reject) {
+            getDb(function(db) {
+                var request, storeName = dbName,
+                    transaction = db.transaction([storeName], "readonly"),
+                    objectStore = transaction.objectStore(storeName);
+                if ("getAll" in objectStore) request = objectStore.getAll(null, 1e4), request.onsuccess = function(event) {
+                    resolve(event.target.result)
+                };
+                else {
+                    var results = [];
+                    request = objectStore.openCursor(), request.onsuccess = function(event) {
+                        var cursor = event.target.result;
+                        cursor ? (results.push(cursor.value), cursor.continue()) : resolve(results)
+                    }
+                }
+                request.onerror = reject
+            })
+        })
+    }
+
+    function get(key) {
+        return new Promise(function(resolve, reject) {
+            getDb(function(db) {
+                var storeName = dbName,
+                    transaction = db.transaction([storeName], "readonly"),
+                    objectStore = transaction.objectStore(storeName),
+                    request = objectStore.get(key);
+                request.onerror = reject, request.onsuccess = function(event) {
+                    resolve(request.result)
+                }
+            })
+        })
+    }
+
+    function set(key, val) {
+        return new Promise(function(resolve, reject) {
+            getDb(function(db) {
+                var storeName = dbName,
+                    transaction = db.transaction([storeName], "readwrite"),
+                    objectStore = transaction.objectStore(storeName),
+                    request = objectStore.put(val, key);
+                request.onerror = reject, request.onsuccess = resolve
+            })
+        })
+    }
+
+    function remove(key) {
+        return new Promise(function(resolve, reject) {
+            getDb(function(db) {
+                var storeName = dbName,
+                    transaction = db.transaction([storeName], "readwrite"),
+                    objectStore = transaction.objectStore(storeName),
+                    request = objectStore.delete(key);
+                request.onerror = reject, request.onsuccess = resolve
+            })
+        })
+    }
+
+    function clear() {
+        return new Promise(function(resolve, reject) {
+            getDb(function(db) {
+                var storeName = dbName,
+                    transaction = db.transaction([storeName], "readwrite"),
+                    objectStore = transaction.objectStore(storeName),
+                    request = objectStore.clear();
+                request.onerror = reject, request.onsuccess = resolve
+            })
+        })
+    }
+    var databaseInstance, indexedDB = self.indexedDB || self.mozIndexedDB || self.webkitIndexedDB || self.msIndexedDB,
+        dbName = (self.IDBTransaction || self.webkitIDBTransaction || self.msIDBTransaction, self.IDBKeyRange || self.webkitIDBKeyRange || self.msIDBKeyRange, "useractions"),
+        dbVersion = 1;
+    return {
+        get: get,
+        set: set,
+        remove: remove,
+        clear: clear,
+        getAll: getAll,
+        getByServerId: getByServerId
+    }
+});