/// <summary>
        /// Take a video with specified options
        /// </summary>
        /// <param name="options">Video Media Options</param>
        /// <param name="token">Cancellation token (currently ignored)</param>
        /// <returns>Media file of new video or null if canceled</returns>
        public async Task <MediaFile> TakeVideoAsync(StoreVideoOptions options, CancellationToken token = default(CancellationToken))
        {
            if (!initialized)
            {
                await Initialize();
            }

            if (!IsCameraAvailable)
            {
                throw new NotSupportedException();
            }

            options.VerifyOptions();

            var capture = new CameraCaptureUI();

            capture.VideoSettings.MaxResolution = GetResolutionFromQuality(options.Quality);
            capture.VideoSettings.AllowTrimming = options?.AllowCropping ?? true;

            if (capture.VideoSettings.AllowTrimming)
            {
                capture.VideoSettings.MaxDurationInSeconds = (float)options.DesiredLength.TotalSeconds;
            }

            capture.VideoSettings.Format = CameraCaptureUIVideoFormat.Mp4;

            var result = await capture.CaptureFileAsync(CameraCaptureUIMode.Video);

            if (result == null)
            {
                return(null);
            }

            string aPath = null;

            if (options?.SaveToAlbum ?? false)
            {
                try
                {
                    var fileNameNoEx = Path.GetFileNameWithoutExtension(result.Path);
                    var copy         = await result.CopyAsync(KnownFolders.VideosLibrary, fileNameNoEx + result.FileType, NameCollisionOption.GenerateUniqueName);

                    aPath = copy.Path;
                }
                catch (Exception ex)
                {
                    Debug.WriteLine("unable to save to album:" + ex);
                }
            }

            return(new MediaFile(result.Path, () => result.OpenStreamForReadAsync().Result, albumPath: aPath));
        }
Example #2
0
        /// <summary>
        /// Take a photo async with specified options
        /// </summary>
        /// <param name="options">Camera Media Options</param>
        /// <param name="token">Cancellation token (currently ignored)</param>
        /// <returns>Media file of photo or null if canceled</returns>
        public async Task <MediaFile> TakePhotoAsync(StoreCameraMediaOptions options, CancellationToken token = default(CancellationToken))
        {
            if (!initialized)
            {
                await Initialize();
            }

            if (!IsCameraAvailable)
            {
                throw new NotSupportedException();
            }

            options.VerifyOptions();

            var capture = new CameraCaptureUI();

            //capture.PhotoSettings.CroppedAspectRatio = new Size(16, 9);
            capture.PhotoSettings.Format        = CameraCaptureUIPhotoFormat.Jpeg;
            capture.PhotoSettings.MaxResolution = GetMaxResolution(options.PhotoSize, options.CustomPhotoSize, options.MaxWidthHeight ?? 0);
            if (options.AllowCropping ?? false)
            {
                capture.PhotoSettings.AllowCropping      = true;
                capture.PhotoSettings.CroppedAspectRatio = new Size(16, 9);
            }
            else
            {
                capture.PhotoSettings.AllowCropping = false;
            }

            var result = await capture.CaptureFileAsync(CameraCaptureUIMode.Photo);

            if (result == null)
            {
                return(null);
            }

            if (options.SaveToAlbum)
            {
                await SaveToAlbum(result, KnownFolders.SavedPictures, options.Directory, options.Name);
            }

            if (IsValidFileName(options.Name))
            {
                var name = EnsureCorrectExtension(options.Name, result.FileType);
                await result.RenameAsync(name, NameCollisionOption.GenerateUniqueName);
            }

            await ResizeAsync(result, options);

            return(MediaFileFromFile(result));
        }
Example #3
0
        /// <summary>
        /// Take a video with specified options
        /// </summary>
        /// <param name="options">Video Media Options</param>
        /// <param name="token">Cancellation token (currently ignored)</param>
        /// <returns>Media file of new video or null if canceled</returns>
        public async Task <MediaFile> TakeVideoAsync(StoreVideoOptions options, CancellationToken token = default(CancellationToken))
        {
            if (!initialized)
            {
                await Initialize();
            }

            if (!IsCameraAvailable)
            {
                throw new NotSupportedException();
            }

            options.VerifyOptions();

            var capture = new CameraCaptureUI();

            capture.VideoSettings.MaxResolution = GetResolutionFromQuality(options.Quality);
            capture.VideoSettings.AllowTrimming = options?.AllowCropping ?? true;

            if (capture.VideoSettings.AllowTrimming)
            {
                capture.VideoSettings.MaxDurationInSeconds = (float)options.DesiredLength.TotalSeconds;
            }

            capture.VideoSettings.Format = CameraCaptureUIVideoFormat.Mp4;

            var result = await capture.CaptureFileAsync(CameraCaptureUIMode.Video);

            if (result == null)
            {
                return(null);
            }

            string aPath = null;

            if (options.SaveToAlbum)
            {
                await SaveToAlbum(result, KnownFolders.VideosLibrary, options.Directory, options.Name);
            }

            return(new MediaFile(result.Path, () => result.OpenStreamForReadAsync().Result, albumPath: aPath));
        }
        /// <summary>
        /// Take a photo async with specified options
        /// </summary>
        /// <param name="options">Camera Media Options</param>
        /// <param name="token">Cancellation token (currently ignored)</param>
        /// <returns>Media file of photo or null if canceled</returns>
        public async Task <MediaFile> TakePhotoAsync(StoreCameraMediaOptions options, CancellationToken token = default(CancellationToken))
        {
            if (!initialized)
            {
                await Initialize();
            }

            if (!IsCameraAvailable)
            {
                throw new NotSupportedException();
            }

            options.VerifyOptions();

            var capture = new CameraCaptureUI();

            capture.PhotoSettings.Format        = CameraCaptureUIPhotoFormat.Jpeg;
            capture.PhotoSettings.MaxResolution = GetMaxResolution(options?.PhotoSize ?? PhotoSize.Full, options?.CustomPhotoSize ?? 100);
            //we can only disable cropping if resolution is set to max
            if (capture.PhotoSettings.MaxResolution == CameraCaptureUIMaxPhotoResolution.HighestAvailable)
            {
                capture.PhotoSettings.AllowCropping = options?.AllowCropping ?? true;
            }

            var result = await capture.CaptureFileAsync(CameraCaptureUIMode.Photo);

            if (result == null)
            {
                return(null);
            }

            var folder = ApplicationData.Current.LocalFolder;

            var path          = options.GetFilePath(folder.Path);
            var directoryFull = Path.GetDirectoryName(path);
            var newFolder     = directoryFull.Replace(folder.Path, string.Empty);

            if (!string.IsNullOrWhiteSpace(newFolder))
            {
                await folder.CreateFolderAsync(newFolder, CreationCollisionOption.OpenIfExists);
            }

            folder = await StorageFolder.GetFolderFromPathAsync(directoryFull);

            var filename = Path.GetFileName(path);

            string aPath = null;

            if (options?.SaveToAlbum ?? false)
            {
                try
                {
                    var fileNameNoEx = Path.GetFileNameWithoutExtension(path);
                    var copy         = await result.CopyAsync(KnownFolders.PicturesLibrary, fileNameNoEx + result.FileType, NameCollisionOption.GenerateUniqueName);

                    aPath = copy.Path;
                }
                catch (Exception ex)
                {
                    Debug.WriteLine("unable to save to album:" + ex);
                }
            }

            var file = await result.CopyAsync(folder, filename, NameCollisionOption.GenerateUniqueName).AsTask();

            return(new MediaFile(file.Path, () => file.OpenStreamForReadAsync().Result, albumPath: aPath));
        }