public SinglePhotoPackage(PHAsset photo)
{
Photo = new PLAsset {
Asset = photo
};
Photo.PopulateProperties();
}
static private IEnumerable <PLAsset> GetPhotosToBeBackedUp()
{
if (PHPhotoLibrary.AuthorizationStatus != PHAuthorizationStatus.Authorized)
{
yield break;
//return null;
}
var collections = PHAssetCollection.FetchAssetCollections(PHAssetCollectionType.SmartAlbum, PHAssetCollectionSubtype.SmartAlbumUserLibrary, null);
var photos = collections.OfType <PHAssetCollection>().SelectMany(x => PHAsset.FetchAssets(x, null).OfType <PHAsset>().Select(x => {
var asset = new PLAsset {
Asset = x,
Id = x.LocalIdentifier
};
return(asset);
})).ToList();
foreach (var asset in Globals.Database.Table <PLAsset>())
{
if (photos.Contains(asset))
{
photos.Remove(asset);
}
}
foreach (var item in photos)
{
item.PopulateProperties();
yield return(item);
}
//return photos.AsReadOnly();
}
public SinglePhotoPackage(PHAsset photo)
{
Photo = new PLAsset {
Asset = photo
};
Photo.Refresh();
}
public void Update(PLAsset photo)
{
IconImage.Image = null;
IconImage.ContentMode = UIViewContentMode.ScaleAspectFill;
NameLabel.Text = photo.FileName;
var type = photo.Type.ToLocalizedString();
var tags = photo.Tags.Unpack().ToLocalizedString();
if (!string.IsNullOrEmpty(tags))
{
TypeLabel.Text = tags;
}
else
{
TypeLabel.Text = type;
}
SizeLabel.Text = null;
PHImageManager.DefaultManager.RequestImageForAsset(photo.Asset, IconImage.Frame.Size, PHImageContentMode.AspectFill, null, (result, info) => {
var error = info.ObjectForKey(PHImageKeys.Error);
if (error == null)
{
InvokeOnMainThread(() => IconImage.Image = result);
}
});
SizeLabel.Text = photo.Size.Bytes().Humanize("0.00", CultureInfo.InvariantCulture);
}
public async Task <bool> CopyToDestination(PLAsset photo, string destPath, IFileSystem fileSystem, DateTime filetime)
{
try
{
if (!photo.IsAvailable)
{
throw new InvalidOperationException("This photo is no longer available.");
}
var options = new PHAssetResourceRequestOptions {
NetworkAccessAllowed = true
};
NSError lastError = null;
var original = photo.Resources.FirstOrDefault(x => x.ResourceType == PHAssetResourceType.FullSizeVideo ||
x.ResourceType == PHAssetResourceType.FullSizePhoto ||
x.ResourceType == PHAssetResourceType.Photo ||
x.ResourceType == PHAssetResourceType.Video ||
x.ResourceType == PHAssetResourceType.Audio);
if (original == null)
{
throw new InvalidOperationException("Backup failed for this photo.");
}
var destTmpFile = destPath + ".temp";
var tcs = new TaskCompletionSource <int>();
long datawritten = 0;
PHAssetResourceManager.DefaultManager.RequestData(original, options, data => {
var bytes = data.ToArray();
WriteToDest(bytes, datawritten, bytes.Length, destTmpFile, fileSystem).Wait();
datawritten += bytes.Length;
}, error => {
if (error != null)
{
tcs.SetException(new InvalidOperationException(lastError.LocalizedDescription));
}
tcs.SetResult(0);
});
await tcs.Task.ConfigureAwait(false);
return(await RenameDestinationFile(fileSystem, destTmpFile, destPath, filetime).ConfigureAwait(false));
}
catch (Exception)
{
return(false);
}
}
private async Task <bool> BackupOneImage(PLAsset photo, string remotePath, IFileSystem fileSystem, bool background)//or video
{
try
{
logger.LogTrace($"Backing up item: {photo.FileName}");
var zipFile = Path.Combine(Paths.Temporary, photo.FileName + ".zip");
File.Delete(zipFile);
FileStream zipStream = null;
SinglePhotoPackage package = null;
var ft = photo.CreationDate;
package = new SinglePhotoPackage(photo);
if (photo.Resources.Count > 1)
{
zipStream = new FileStream(zipFile, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
}
try
{
if (zipStream != null)
{
package.WriteArchive(zipStream);
zipStream.Seek(0, SeekOrigin.Begin);
var destZipFile = Path.Combine(remotePath, Path.GetFileNameWithoutExtension(photo.FileName) + ".PLAsset");
if (!await CopyToDestination(zipStream, destZipFile, fileSystem, ft).ConfigureAwait(false))
{
return(false);
}
}
var destOriginalFile = Path.Combine(remotePath, photo.FileName);
if (background && (photo.Size > 30L * 1024 * 1024))
{
if (!await CopyToDestination(photo.Asset, destOriginalFile, fileSystem, ft).ConfigureAwait(false))
{
return(false);
}
}
else
{
if (!await CopyToDestination(photo, destOriginalFile, fileSystem, ft).ConfigureAwait(false))
{
return(false);
}
}
Globals.Database.Insert(photo);
}
catch (Exception exception)
{
logger.LogError(exception, $"Backup failed for item: {photo.FileName}");
}
finally
{
zipStream?.Dispose();
}
try
{
File.Delete(zipFile);
}
catch
{// Ignored.
}
return(true);
}
catch (Exception)
{
return(false);
}
}
public SinglePhotoPackage(PLAsset photo)
{
Photo = photo;
}
