public async Task GetItemFileAsync(
IApiClient apiClient,
ServerInfo server,
LocalItem item,
string syncJobItemId,
IProgress<double> transferProgress,
CancellationToken cancellationToken)
{
var downloadUrl = apiClient.GetSyncJobItemFileUrl(syncJobItemId);
await CreateDownload(downloadUrl, apiClient, item);
}
public async Task AddOrUpdate(LocalItem item)
{
var existingItem = await GetItemInternal(x => x.Id == item.Id);
if (existingItem == null)
{
_items.Add(item);
}
else
{
item.CopyItem(existingItem);
}
await SaveItems();
}
public async Task GetItemFileAsync(IApiClient apiClient,
ServerInfo server,
LocalItem item,
string syncJobItemId,
IProgress<double> transferProgress,
CancellationToken cancellationToken = default(CancellationToken))
{
_logger.Debug("Downloading media with Id {0} to local repository", item.Item.Id);
using (var stream = await apiClient.GetSyncJobItemFile(syncJobItemId, cancellationToken).ConfigureAwait(false))
{
await _localAssetManager.SaveMedia(stream, item, server).ConfigureAwait(false);
}
transferProgress.Report(100);
}
private async Task CreateDownload(string source, IApiClient client, LocalItem localItem)
{
var existingRequest = BackgroundTransferService.Requests.FirstOrDefault(x => x.Tag != null && x.Tag.Contains(localItem.Id));
if (existingRequest != null)
{
return;
}
await _storageService.CreateDirectoryIfNotThere("AnyTime");
await _storageService.CreateDirectoryIfNotThere("Shared\\Transfers");
await _storageService.CreateDirectoryIfNotThere("Shared\\Transfers\\Sync");
var stringVersion = ApplicationManifest.Current.App.Version;
var downloader = new BackgroundTransferRequest(new Uri(source, UriKind.Absolute));
downloader.Headers.Add("X-MediaBrowser-Token", client.AccessToken);
var authorization = string.Format("MediaBrowser UserId=\"{0}\", Client=\"{1}\", Device=\"{2}\", DeviceId=\"{3}\", Version=\"{4}\"", client.CurrentUserId, client.ClientName, client.DeviceName, client.DeviceId, stringVersion);
downloader.Headers.Add("Authorization", authorization);
downloader.Method = "GET";
downloader.Tag = JsonConvert.SerializeObject(new JobData(localItem.Id, localItem.LocalPath, localItem.Item.Name, localItem.Item.Type));
var downloadLocation = new Uri(string.Format(Constants.AnyTime.DownloadLocation, localItem.Id), UriKind.RelativeOrAbsolute);
downloader.DownloadLocation = downloadLocation;
downloader.TransferStatusChanged += DownloaderOnTransferStatusChanged;
if (BackgroundTransferService.Requests.Count() == 25)
{
// TODO: error or something
var i = 1;
}
var complete = BackgroundTransferService.Requests.Where(x => x.TransferStatus == TransferStatus.Completed).ToList();
if (!complete.IsNullOrEmpty())
{
foreach (var request in complete)
{
BackgroundTransferService.Remove(request);
}
}
_transferService.Add(downloader);
}
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);
}
/// <summary>
/// Deletes the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>Task.</returns>
public Task Delete(LocalItem item)
{
return _itemRepository.Delete(item.Id);
}
public Task SaveMedia(Stream stream, LocalItem localItem, ServerInfo server)
{
_logger.Debug("Saving media to " + localItem.LocalPath);
return _fileRepository.SaveFile(stream, localItem.LocalPath);
}
private string GetSubtitleSaveFileName(LocalItem item, string language, bool isForced)
{
var path = item.LocalPath;
var name = Path.GetFileNameWithoutExtension(path);
if (!string.IsNullOrWhiteSpace(language))
{
name += "." + language.ToLower();
}
if (isForced)
{
name += ".foreign";
}
return name;
}
public async Task<string> SaveSubtitles(Stream stream,
string format,
LocalItem item,
string language,
bool isForced)
{
var path = item.LocalPath;
var filename = GetSubtitleSaveFileName(item, language, isForced) + "." + format.ToLower();
var parentPath = _fileRepository.GetParentDirectoryPath(path);
path = Path.Combine(parentPath, filename);
await _fileRepository.SaveFile(stream, path);
return path;
}
private async Task GetItemSubtitles(IApiClient apiClient,
SyncedItem jobItem,
LocalItem item,
CancellationToken cancellationToken)
{
var hasDownloads = false;
var mediaSource = jobItem.Item.MediaSources.FirstOrDefault();
if (mediaSource == null)
{
_logger.Error("Cannot download subtitles because video has no media source info.");
return;
}
foreach (var file in jobItem.AdditionalFiles.Where(i => i.Type == ItemFileType.Subtitles))
{
var subtitleStream = mediaSource.MediaStreams.FirstOrDefault(i => i.Type == MediaStreamType.Subtitle && i.Index == file.Index);
if (subtitleStream != null)
{
using (var response = await apiClient.GetSyncJobItemAdditionalFile(jobItem.SyncJobItemId, file.Name, cancellationToken).ConfigureAwait(false))
{
var path = await _localAssetManager.SaveSubtitles(response, subtitleStream.Codec, item, subtitleStream.Language, subtitleStream.IsForced).ConfigureAwait(false);
subtitleStream.Path = path;
item.AdditionalFiles.Add(path);
}
hasDownloads = true;
}
else
{
_logger.Error("Cannot download subtitles because matching stream info wasn't found.");
}
}
// Save the changes to the item
if (hasDownloads)
{
await _localAssetManager.AddOrUpdate(item).ConfigureAwait(false);
}
}
public Task<string> SaveSubtitles(Stream stream, string format, LocalItem item, string language, bool isForced)
{
throw new NotImplementedException();
}
public Task AddOrUpdate(LocalItem item)
{
return Task.FromResult(true);
}
private string[] GetRemoteSubtitlePath(LocalItem item, MediaStream stream, IServerSyncProvider provider, SyncTarget target)
{
var filename = GetSubtitleSaveFileName(item, stream.Language, stream.IsForced) + "." + stream.Codec.ToLower();
var pathParts = item.LocalPath.Split(PathSeparatorChar);
var list = pathParts.Take(pathParts.Length - 1).ToList();
list.Add(filename);
return list.ToArray();
}
private async Task SendSubtitles(LocalItem localItem, MediaSourceInfo mediaSource, IServerSyncProvider provider, ISyncDataProvider dataProvider, SyncTarget target, SyncOptions options, CancellationToken cancellationToken)
{
var failedSubtitles = new List<MediaStream>();
var requiresSave = false;
foreach (var mediaStream in mediaSource.MediaStreams
.Where(i => i.Type == MediaStreamType.Subtitle && i.IsExternal)
.ToList())
{
try
{
var remotePath = GetRemoteSubtitlePath(localItem, mediaStream, provider, target);
var sendFileResult = await SendFile(provider, mediaStream.Path, remotePath, target, options, new Progress<double>(), cancellationToken).ConfigureAwait(false);
// This is the path that will be used when talking to the provider
mediaStream.ExternalId = sendFileResult.Id;
// Keep track of all additional files for cleanup later.
localItem.AdditionalFiles.Add(sendFileResult.Id);
// This is the public path clients will use
mediaStream.Path = sendFileResult.Path;
requiresSave = true;
}
catch (Exception ex)
{
_logger.ErrorException("Error sending subtitle stream", ex);
failedSubtitles.Add(mediaStream);
}
}
if (failedSubtitles.Count > 0)
{
mediaSource.MediaStreams = mediaSource.MediaStreams.Except(failedSubtitles).ToList();
requiresSave = true;
}
if (requiresSave)
{
await dataProvider.AddOrUpdate(target, localItem).ConfigureAwait(false);
}
}
private void SetStaticMediaSourceInfo(LocalItem item, MediaSourceInfo mediaSource)
{
mediaSource.Id = item.Id;
mediaSource.SupportsTranscoding = false;
}
private void SetStaticMediaSourceInfo(LocalItem item, MediaSourceInfo mediaSource)
{
mediaSource.Id = item.Id;
mediaSource.SupportsTranscoding = false;
if (mediaSource.Protocol == Model.MediaInfo.MediaProtocol.File)
{
mediaSource.ETag = item.Id;
}
}
public Task SaveMedia(Stream stream, LocalItem localItem, ServerInfo server)
{
return Task.FromResult(true);
}
/// <summary>
/// Adds the or update.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>Task.</returns>
public Task AddOrUpdate(LocalItem item)
{
return _itemRepository.AddOrUpdate(item);
}
/// <summary>
/// Gets the files.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>Task<List<ItemFileInfo>>.</returns>
public async Task<List<ItemFileInfo>> GetFiles(LocalItem item)
{
var path = item.LocalPath;
path = _fileRepository.GetParentDirectoryPath(path);
var list = await _fileRepository.GetFileSystemEntries(path).ConfigureAwait(false);
var itemFiles = new List<ItemFileInfo>();
var name = Path.GetFileNameWithoutExtension(item.LocalPath);
foreach (var file in list.Where(f => f.Name.Contains(name)))
{
var itemFile = new ItemFileInfo
{
Path = file.Path,
Name = file.Name
};
if (IsSubtitleFile(file.Name))
{
itemFile.Type = ItemFileType.Subtitles;
}
else if (!IsImageFile(file.Name))
{
itemFile.Type = ItemFileType.Media;
}
itemFiles.Add(itemFile);
}
return itemFiles;
}
public Task Delete(LocalItem item)
{
return Task.FromResult(true);
}
private async Task GetItemImages(IApiClient apiClient,
LocalItem item,
CancellationToken cancellationToken)
{
var libraryItem = item.Item;
if (libraryItem.HasPrimaryImage)
{
await DownloadImage(apiClient, item.ServerId, libraryItem.Id, libraryItem.ImageTags[ImageType.Primary], ImageType.Primary, cancellationToken)
.ConfigureAwait(false);
}
// Container images
// Series Primary
if (!string.IsNullOrWhiteSpace(libraryItem.SeriesPrimaryImageTag))
{
await DownloadImage(apiClient, item.ServerId, libraryItem.SeriesId, libraryItem.SeriesPrimaryImageTag, ImageType.Primary, cancellationToken)
.ConfigureAwait(false);
}
// Series Thumb
if (!string.IsNullOrWhiteSpace(libraryItem.SeriesThumbImageTag))
{
await DownloadImage(apiClient, item.ServerId, libraryItem.SeriesId, libraryItem.SeriesThumbImageTag, ImageType.Thumb, cancellationToken)
.ConfigureAwait(false);
}
// Album Primary
if (!string.IsNullOrWhiteSpace(libraryItem.AlbumPrimaryImageTag))
{
await DownloadImage(apiClient, item.ServerId, libraryItem.AlbumId, libraryItem.AlbumPrimaryImageTag, ImageType.Primary, cancellationToken)
.ConfigureAwait(false);
}
}
public Task<List<ItemFileInfo>> GetFiles(LocalItem item)
{
return Task.FromResult(new List<ItemFileInfo>());
}
