Example #1
0
        public static async Task <GeotaggingResult> AddGeotag(Stream image, Geoposition location)
        {
            var result = new GeotaggingResult()
            {
                OperationResult = GeotaggingResult.Result.OK,
                Image           = image,
            };

            // From UWP, a stream from HttpResponseMessage doesn't support seeking.
            if (!image.CanSeek)
            {
                var original = image;
                var seekable = new MemoryStream();
                image.CopyTo(seekable);
                seekable.Seek(0, SeekOrigin.Begin);
                image = seekable;
                original.Dispose();
            }

            try
            {
                result.Image = await MetaDataOperator.AddGeopositionAsync(image, location, false);
            }
            catch (GpsInformationAlreadyExistsException)
            {
                result.OperationResult = GeotaggingResult.Result.GeotagAlreadyExists;
            }
            catch
            {
                result.OperationResult = GeotaggingResult.Result.UnExpectedError;
            }

            return(result);
        }
Example #2
0
        private async Task DownloadToSave(DownloadRequest req)
        {
            DebugUtil.Log("Download picture: " + req.Uri.OriginalString);
            try
            {
                var geoResult = GeotaggingResult.NotRequested;

                var res = await HttpClient.GetAsync(req.Uri, HttpCompletionOption.ResponseContentRead).ConfigureAwait(false);

                switch (res.StatusCode)
                {
                case HttpStatusCode.OK:
                    break;

                case HttpStatusCode.Gone:
                    req.Error.Raise(DownloaderError.Gone, geoResult);
                    return;

                default:
                    req.Error.Raise(DownloaderError.Network, geoResult);
                    return;
                }

                var imageStream = await res.Content.ReadAsStreamAsync().ConfigureAwait(false);

                if (req.Mediatype == Mediatype.Image && req.GeoPosition != null)
                {
                    try
                    {
                        imageStream = await MetaDataOperator.AddGeopositionAsync(imageStream, req.GeoPosition, false);

                        geoResult = Utility.GeotaggingResult.OK;
                    }
                    catch (GpsInformationAlreadyExistsException)
                    {
                        geoResult = GeotaggingResult.GeotagAlreadyExists;
                    }
                    catch
                    {
                        geoResult = GeotaggingResult.UnExpectedError;
                    }
                }

                using (imageStream)
                {
                    StorageFolder rootFolder;
                    switch (req.Mediatype)
                    {
                    case Mediatype.Image:
                        rootFolder = KnownFolders.PicturesLibrary;
                        break;

                    case Mediatype.Video:
                        rootFolder = KnownFolders.PicturesLibrary;
                        // Use Pictures folder according to the behavior of built-in Camera apps
                        // rootFolder = KnownFolders.VideosLibrary;
                        break;

                    default:
                        return;
                    }

                    var folder = await rootFolder.CreateFolderAsync(DIRECTORY_NAME, CreationCollisionOption.OpenIfExists);

                    var filename = string.Format(req.NameBase + "_{0:yyyyMMdd_HHmmss}" + req.extension, DateTime.Now);
                    var file     = await folder.CreateFileAsync(filename, CreationCollisionOption.GenerateUniqueName);

                    using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
                    {
                        var buffer = new byte[BUFFER_SIZE];
                        using (var os = stream.GetOutputStreamAt(0))
                        {
                            int read = 0;
                            while ((read = imageStream.Read(buffer, 0, BUFFER_SIZE)) != 0)
                            {
                                await os.WriteAsync(buffer.AsBuffer(0, read));
                            }
                        }
                    }
                    req.Completed.Raise(folder, file, geoResult);
                    return;
                }
            }
            catch (Exception e)
            {
                DebugUtil.Log(e.Message);
                DebugUtil.Log(e.StackTrace);
                req.Error.Raise(DownloaderError.Unknown, GeotaggingResult.NotRequested); // TODO
            }
        }