public async Task Sync(IServerSyncProvider provider,
ISyncDataProvider dataProvider,
SyncTarget target,
IProgress<double> progress,
CancellationToken cancellationToken)
{
var serverId = _appHost.SystemId;
var serverName = _appHost.FriendlyName;
await SyncData(provider, dataProvider, serverId, target, cancellationToken).ConfigureAwait(false);
progress.Report(3);
var innerProgress = new ActionableProgress<double>();
innerProgress.RegisterAction(pct =>
{
var totalProgress = pct * .97;
totalProgress += 1;
progress.Report(totalProgress);
});
await GetNewMedia(provider, dataProvider, target, serverId, serverName, innerProgress, cancellationToken);
// Do the data sync twice so the server knows what was removed from the device
await SyncData(provider, dataProvider, serverId, target, cancellationToken).ConfigureAwait(false);
progress.Report(100);
}
/// <summary>
/// Default ctor.
/// </summary>
public RequestFactory(SyncTarget target, string accessToken)
{
var config = PluginConfiguration.Configuration;
this.syncAccount = config.SyncAccounts.FirstOrDefault(x => x.Id == target.Id);
this.accessToken = accessToken;
}
public IEnumerable<SyncQualityOption> GetQualityOptions(SyncTarget target)
{
return new List<SyncQualityOption>
{
new SyncQualityOption
{
Name = "Original",
Id = "original",
Description = "Syncs original files as-is, regardless of whether the device is capable of playing them or not."
},
new SyncQualityOption
{
Name = "High",
Id = "high",
IsDefault = true
},
new SyncQualityOption
{
Name = "Medium",
Id = "medium"
},
new SyncQualityOption
{
Name = "Low",
Id = "low"
}
};
}
public DeviceProfile GetDeviceProfile(SyncTarget target, string profile, string quality)
{
var caps = _deviceManager.GetCapabilities(target.Id);
var deviceProfile = caps == null || caps.DeviceProfile == null ? new DeviceProfile() : caps.DeviceProfile;
deviceProfile.MaxStaticBitrate = SyncHelper.AdjustBitrate(deviceProfile.MaxStaticBitrate, quality);
return deviceProfile;
}
public OneDriveCredentials(IConfigurationRetriever configurationRetriever, ILiveAuthenticationApi liveAuthenticationApi, SyncTarget target)
{
_configurationRetriever = configurationRetriever;
_liveAuthenticationApi = liveAuthenticationApi;
_syncAccountId = target.Id;
var syncAccount = configurationRetriever.GetSyncAccount(target.Id);
_accessToken = syncAccount.AccessToken;
}
public OneDriveSyncJob FindSyncJob(SyncTarget target, string localPath, string hash)
{
var syncJob = SyncJobs.FirstOrDefault(x => x.Target == target && x.LocalPath == localPath && x.Hash == hash);
if (syncJob != null && syncJob.ExpirationDateTime < DateTime.Now)
{
RemoveSyncJob(syncJob);
syncJob = null;
}
return syncJob;
}
public async Task<SyncedFileInfo> SendFile(Stream stream, string[] remotePath, SyncTarget target, IProgress<double> progress, CancellationToken cancellationToken)
{
var fullPath = GetFullPath(remotePath, target);
_fileSystem.CreateDirectory(Path.GetDirectoryName(fullPath));
_logger.Debug("Folder sync saving stream to {0}", fullPath);
using (var fileStream = _fileSystem.GetFileStream(fullPath, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read, true))
{
await stream.CopyToAsync(fileStream).ConfigureAwait(false);
return GetSyncedFileInfo(fullPath);
}
}
public string GetFullPath(IEnumerable<string> paths, SyncTarget target)
{
var account = GetSyncAccounts()
.FirstOrDefault(i => string.Equals(i.Id, target.Id, StringComparison.OrdinalIgnoreCase));
if (account == null)
{
throw new ArgumentException("Invalid SyncTarget supplied.");
}
var list = paths.ToList();
list.Insert(0, account.Path);
return Path.Combine(list.ToArray());
}
public async Task<SyncedFileInfo> GetSyncedFileInfo(string id, SyncTarget target, CancellationToken cancellationToken)
{
_logger.Debug("Getting synced file info for {0} from {1}", id, target.Name);
var googleCredentials = GetGoogleCredentials(target);
var url = await _googleDriveService.CreateDownloadUrl(id, googleCredentials, cancellationToken).ConfigureAwait(false);
return new SyncedFileInfo
{
Path = url,
Protocol = MediaProtocol.Http,
Id = id
};
}
public async Task<SyncedFileInfo> SendFile(Stream stream, string[] pathParts, SyncTarget target, IProgress<double> progress, CancellationToken cancellationToken)
{
var path = GetFullPath(pathParts, target);
_logger.Debug("Sending file {0} to {1}", path, target.Name);
var syncAccount = _configurationRetriever.GetSyncAccount(target.Id);
await UploadFile(path, stream, syncAccount.AccessToken, cancellationToken);
return new SyncedFileInfo
{
Id = path,
Path = path,
Protocol = MediaProtocol.Http
};
}
public async Task<SyncedFileInfo> SendFile(Stream stream, string[] remotePath, SyncTarget target, IProgress<double> progress, CancellationToken cancellationToken)
{
var fullPath = GetFullPath(remotePath, target);
Directory.CreateDirectory(Path.GetDirectoryName(fullPath));
using (var fileStream = _fileSystem.GetFileStream(fullPath, FileMode.Create, FileAccess.Write, FileShare.Read, true))
{
await stream.CopyToAsync(fileStream).ConfigureAwait(false);
return new SyncedFileInfo
{
Path = fullPath,
Protocol = MediaProtocol.File,
Id = fullPath
};
}
}
private async Task SyncData(IServerSyncProvider provider,
ISyncDataProvider dataProvider,
string serverId,
SyncTarget target,
CancellationToken cancellationToken)
{
var localItems = await dataProvider.GetLocalItems(target, serverId).ConfigureAwait(false);
var remoteFiles = await provider.GetFiles(new FileQuery(), target, cancellationToken).ConfigureAwait(false);
var remoteIds = remoteFiles.Items.Select(i => i.Id).ToList();
var jobItemIds = new List<string>();
foreach (var localItem in localItems)
{
// TODO: Remove this after a while
if (string.IsNullOrWhiteSpace(localItem.FileId))
{
jobItemIds.Add(localItem.SyncJobItemId);
}
else if (remoteIds.Contains(localItem.FileId, StringComparer.OrdinalIgnoreCase))
{
jobItemIds.Add(localItem.SyncJobItemId);
}
}
var result = await _syncManager.SyncData(new SyncDataRequest
{
TargetId = target.Id,
SyncJobItemIds = jobItemIds
}).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
foreach (var itemIdToRemove in result.ItemIdsToRemove)
{
try
{
await RemoveItem(provider, dataProvider, serverId, itemIdToRemove, target, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
_logger.ErrorException("Error deleting item from device. Id: {0}", ex, itemIdToRemove);
}
}
}
public async Task<SyncedFileInfo> SendFile(Stream stream, string[] pathParts, SyncTarget target, IProgress<double> progress, CancellationToken cancellationToken)
{
_logger.Debug("Sending file {0} to {1}", string.Join("/", pathParts), target.Name);
var syncAccount = _configurationRetriever.GetSyncAccount(target.Id);
var googleCredentials = GetGoogleCredentials(target);
var file = await _googleDriveService.UploadFile(stream, pathParts, syncAccount.FolderId, googleCredentials, progress, cancellationToken);
return new SyncedFileInfo
{
Path = file.Item2,
Protocol = MediaProtocol.Http,
Id = file.Item1
};
}
public async Task<SyncedFileInfo> GetSyncedFileInfo(string id, SyncTarget target, CancellationToken cancellationToken)
{
_logger.Debug("Getting synced file info for {0} from {1}", id, target.Name);
try
{
return await TryGetSyncedFileInfo(id, target, cancellationToken);
}
catch (HttpException ex)
{
if (ex.StatusCode == HttpStatusCode.NotFound)
{
throw new FileNotFoundException("File not found", ex);
}
throw;
}
}
public async Task DeleteFile(string id, SyncTarget target, CancellationToken cancellationToken)
{
try
{
var oneDriveCredentials = CreateOneDriveCredentials(target);
await _oneDriveApi.Delete(id, oneDriveCredentials, cancellationToken);
}
catch (HttpException ex)
{
if (ex.StatusCode == HttpStatusCode.NotFound)
{
throw new FileNotFoundException("File not found", ex);
}
throw;
}
}
public async Task<SyncedFileInfo> SendFile(Stream stream, string[] pathParts, SyncTarget target, IProgress<double> progress, CancellationToken cancellationToken)
{
string path = GetFullPath(pathParts);
_logger.Debug("Sending file {0} to {1}", path, target.Name);
var oneDriveCredentials = CreateOneDriveCredentials(target);
await CreateFolderHierarchy(pathParts, oneDriveCredentials, cancellationToken);
var uploadSession = await _oneDriveApi.CreateUploadSession(path, oneDriveCredentials, cancellationToken);
var id = await UploadFile(uploadSession.uploadUrl, stream, oneDriveCredentials, cancellationToken);
return new SyncedFileInfo
{
Id = id,
Path = path,
Protocol = MediaProtocol.Http
};
}
public Task<QueryResult<FileSystemMetadata>> GetFiles(string id, SyncTarget target, CancellationToken cancellationToken)
{
var account = GetSyncAccounts()
.FirstOrDefault(i => string.Equals(i.Id, target.Id, StringComparison.OrdinalIgnoreCase));
if (account == null)
{
throw new ArgumentException("Invalid SyncTarget supplied.");
}
var result = new QueryResult<FileSystemMetadata>();
var file = _fileSystem.GetFileSystemInfo(id);
if (file.Exists)
{
result.TotalRecordCount = 1;
result.Items = new[] { file }.ToArray();
}
return Task.FromResult(result);
}
public Task DeleteFile(string id, SyncTarget target, CancellationToken cancellationToken)
{
return Task.Run(() =>
{
File.Delete(id);
var account = GetSyncAccounts()
.FirstOrDefault(i => string.Equals(i.Id, target.Id, StringComparison.OrdinalIgnoreCase));
if (account != null)
{
try
{
DeleteEmptyFolders(account.Path);
}
catch
{
}
}
}, cancellationToken);
}
private void AddMediaSource(List<MediaSourceInfo> list,
LocalItem item,
MediaSourceInfo mediaSource,
IServerSyncProvider provider,
SyncTarget target)
{
SetStaticMediaSourceInfo(item, mediaSource);
var requiresDynamicAccess = provider as IHasDynamicAccess;
if (requiresDynamicAccess != null)
{
mediaSource.RequiresOpening = true;
var keyList = new List<string>();
keyList.Add(provider.GetType().FullName.GetMD5().ToString("N"));
keyList.Add(target.Id.GetMD5().ToString("N"));
keyList.Add(item.Id);
mediaSource.OpenToken = string.Join(StreamIdDelimeterString, keyList.ToArray());
}
list.Add(mediaSource);
}
private IEnumerable<SyncQualityOption> GetQualityOptions(ISyncProvider provider, SyncTarget target, User user)
{
var hasQuality = provider as IHasSyncQuality;
if (hasQuality != null)
{
var options = hasQuality.GetQualityOptions(target);
if (user != null && !user.Policy.EnableSyncTranscoding)
{
options = options.Where(i => i.IsOriginalQuality);
}
return options;
}
// Default options for providers that don't override
return new List<SyncQualityOption>
{
new SyncQualityOption
{
Name = "High",
Id = "high",
IsDefault = true
},
new SyncQualityOption
{
Name = "Medium",
Id = "medium"
},
new SyncQualityOption
{
Name = "Low",
Id = "low"
},
new SyncQualityOption
{
Name = "Custom",
Id = "custom"
}
};
}
private IEnumerable<SyncProfileOption> GetProfileOptions(ISyncProvider provider, SyncTarget target, User user)
{
var hasQuality = provider as IHasSyncQuality;
if (hasQuality != null)
{
return hasQuality.GetProfileOptions(target);
}
var list = new List<SyncProfileOption>();
list.Add(new SyncProfileOption
{
Name = "Original",
Id = "Original",
Description = "Syncs original files as-is.",
EnableQualityOptions = false
});
if (user == null || user.Policy.EnableSyncTranscoding)
{
list.Add(new SyncProfileOption
{
Name = "Baseline",
Id = "baseline",
Description = "Designed for compatibility with all devices, including web browsers. Targets H264/AAC video and MP3 audio."
});
list.Add(new SyncProfileOption
{
Name = "General",
Id = "general",
Description = "Designed for compatibility with Chromecast, Roku, Smart TV's, and other similar devices. Targets H264/AAC/AC3 video and MP3 audio.",
IsDefault = true
});
}
return list;
}
public DeviceProfile GetDeviceProfile(SyncTarget target)
{
return new DeviceProfile();
}
private SyncJobOptions GetSyncJobOptions(ISyncProvider provider, SyncTarget target, string profile, string quality)
{
var hasProfile = provider as IHasSyncQuality;
if (hasProfile != null)
{
return hasProfile.GetSyncJobOptions(target, profile, quality);
}
return GetDefaultSyncJobOptions(profile, quality);
}
private string GetSyncTargetId(ISyncProvider provider, SyncTarget target)
{
var hasUniqueId = provider as IHasUniqueTargetIds;
if (hasUniqueId != null)
{
return target.Id;
}
return target.Id;
//var providerId = GetSyncProviderId(provider);
//return (providerId + "-" + target.Id).GetMD5().ToString("N");
}
public Task<Stream> GetFile(string id, SyncTarget target, IProgress<double> progress, CancellationToken cancellationToken)
{
return Task.FromResult((Stream)File.OpenRead(id));
}
public SyncJobOptions GetSyncJobOptions(SyncTarget target, string profile, string quality)
{
var isConverting = !string.Equals(quality, "original", StringComparison.OrdinalIgnoreCase);
return new SyncJobOptions
{
DeviceProfile = GetDeviceProfile(target, profile, quality),
IsConverting = isConverting
};
}
public Task<QueryResult<FileMetadata>> GetFiles(FileQuery query, SyncTarget target, CancellationToken cancellationToken)
{
var account = GetSyncAccounts()
.FirstOrDefault(i => string.Equals(i.Id, target.Id, StringComparison.OrdinalIgnoreCase));
if (account == null)
{
throw new ArgumentException("Invalid SyncTarget supplied.");
}
var result = new QueryResult<FileMetadata>();
if (!string.IsNullOrWhiteSpace(query.Id))
{
var file = _fileSystem.GetFileSystemInfo(query.Id);
if (file.Exists)
{
result.TotalRecordCount = 1;
result.Items = new[] { file }.Select(GetFile).ToArray();
}
return Task.FromResult(result);
}
if (query.FullPath != null && query.FullPath.Length > 0)
{
var file = _fileSystem.GetFileSystemInfo(query.FullPath[0]);
if (file.Exists)
{
result.TotalRecordCount = 1;
result.Items = new[] { file }.Select(GetFile).ToArray();
}
return Task.FromResult(result);
}
var files = _fileSystem.GetFiles(account.Path, true)
.Select(GetFile)
.ToArray();
result.Items = files;
result.TotalRecordCount = files.Length;
return Task.FromResult(result);
}
public Task<SyncedFileInfo> SendFile(string path, string[] pathParts, SyncTarget target, IProgress<double> progress, CancellationToken cancellationToken)
{
var fullPath = GetFullPath(pathParts, target);
Directory.CreateDirectory(Path.GetDirectoryName(fullPath));
File.Copy(path, fullPath, true);
return Task.FromResult(new SyncedFileInfo
{
Path = fullPath,
Protocol = MediaProtocol.File,
Id = fullPath
});
}
public ISyncDataProvider GetDataProvider(IServerSyncProvider provider, SyncTarget target)
{
return _dataProviders.GetOrAdd(target.Id, key => new TargetDataProvider(provider, target, _appHost, _logger, _json, _fileSystem, _config.CommonApplicationPaths));
}
public IEnumerable<SyncProfileOption> GetProfileOptions(SyncTarget target)
{
return new List<SyncProfileOption>();
}
