/// <summary>
///
/// </summary>
/// <param name="withData">if false data will be null</param>
/// <param name="options"></param>
/// <returns>Return path and data in bytes</returns>
public static async Task <FileItem> TakeVideo(bool withData = true, StoreVideoOptions options = null)
{
try
{
FileItem result = new FileItem();
await CrossMedia.Current.Initialize();
if (!CrossMedia.Current.IsTakeVideoSupported || !CrossMedia.Current.IsCameraAvailable)
{
throw new InvalidOperationException("Video taking is not supported");
}
var file = await CrossMedia.Current.TakeVideoAsync(options ?? new StoreVideoOptions());
if (file == null)
{
return(null);
}
result.Url = file.Path;
result.FileName = Path.GetFileName(file.Path);
if (withData)
{
result.Data = file.GetStream();
}
file.Dispose();
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
private static MediaPickerController SetupController(MediaPickerDelegate mpDelegate, UIImagePickerControllerSourceType sourceType, string mediaType, StoreCameraMediaOptions options = null)
{
var picker = new MediaPickerController(mpDelegate);
picker.MediaTypes = new[] { mediaType };
picker.SourceType = sourceType;
if (sourceType == UIImagePickerControllerSourceType.Camera)
{
picker.CameraDevice = GetUICameraDevice(options.DefaultCamera);
if (mediaType == TypeImage)
{
picker.CameraCaptureMode = UIImagePickerControllerCameraCaptureMode.Photo;
}
else if (mediaType == TypeMovie)
{
StoreVideoOptions voptions = (StoreVideoOptions)options;
picker.CameraCaptureMode = UIImagePickerControllerCameraCaptureMode.Video;
picker.VideoQuality = GetQuailty(voptions.Quality);
picker.VideoMaximumDuration = voptions.DesiredLength.TotalSeconds;
}
}
return(picker);
}
/// <summary>
/// Take a video with specified options
/// </summary>
/// <param name="options">Video Media Options</param>
/// <returns>Media file of new video or null if canceled</returns>
public async Task <MediaFile> TakeVideoAsync(StoreVideoOptions options, CancellationToken token = default(CancellationToken))
{
if (!IsTakeVideoSupported)
{
throw new NotSupportedException();
}
if (!IsCameraAvailable)
{
throw new NotSupportedException();
}
CheckUsageDescription(cameraDescription, microphoneDescription);
if (options.SaveToAlbum)
{
CheckUsageDescription(photoAddDescription);
}
VerifyCameraOptions(options);
var permissionsToCheck = new List <Permission> {
Permission.Camera, Permission.Microphone
};
if (options.SaveToAlbum)
{
permissionsToCheck.Add(Permission.Photos);
}
await CheckPermissions(permissionsToCheck.ToArray());
return(await GetMediaAsync(UIImagePickerControllerSourceType.Camera, TypeMovie, options, token));
}
public async Task <MediaFile> TakeMediaAsync(StoreVideoOptions options)
{
if (!IsTakeVideoSupported)
{
throw new NotSupportedException();
}
if (!IsCameraAvailable)
{
throw new NotSupportedException();
}
CheckUsageDescription(cameraDescription, microphoneDescription);
if (options.SaveToAlbum)
{
CheckUsageDescription(photoAddDescription);
}
VerifyCameraOptions(options);
var permissionsToCheck = new List <string> {
nameof(Permissions.Camera), nameof(Permissions.Microphone)
};
//if (options.SaveToAlbum)
// permissionsToCheck.Add(nameof(Permissions.Photos));
await CheckPermissions(permissionsToCheck.ToArray());
VerifyCameraOptions(options);
return(await GetMediaAsync(UIImagePickerControllerSourceType.Camera, TypeAll, options));
}
/// <summary>
/// Setting Camera Options for Take Video
/// In Tizen, the following options are not available.
/// - options.SaveToAlbum
/// - options.Location
/// - options.Quality
/// - options.DesiredLength
/// </summary>
/// <param name="options">StoreVideoOptions from Media.Plugin</param>
private void SetOptions(StoreVideoOptions options, ref AppControl appControl)
{
if (appControl == null)
throw new ObjectDisposedException("AppControl");
options.VerifyOptions();
appControl.ExtraData.Add(EX_KEY_ALLOW_SWITCH, EX_VAL_TRUE);
appControl.ExtraData.Add(EX_KEY_REQ_DESTORY, EX_VAL_TRUE);
if (options.DefaultCamera == Abstractions.CameraDevice.Front)
appControl.ExtraData.Add(EX_KEY_SELFIE_MODE, EX_VAL_TRUE);
else
appControl.ExtraData.Add(EX_KEY_SELFIE_MODE, EX_VAL_FALSE);
switch (options.PhotoSize)
{
case PhotoSize.Small:
appControl.ExtraData.Add(EX_KEY_VIDEO_RESOLUTION, EX_VAL_SMALL_RESOLUTION);
break;
case PhotoSize.Full:
case PhotoSize.Large:
case PhotoSize.Medium:
case PhotoSize.MaxWidthHeight:
case PhotoSize.Custom:
default:
appControl.ExtraData.Add(EX_KEY_VIDEO_RESOLUTION, EX_VAL_DEFAULT_RESOLUTION);
break;
}
// Because there is a question about whether DesiredSize is initialized, the option works when it is above a minimum value. (500K)
if (options.DesiredSize > MIN_VIDEO_DESIRE_SIZE)
appControl.ExtraData.Add(EX_KEY_VIDEO_SIZE_LIMIT, options.DesiredSize.ToString());
}
/// <summary>
/// Take a video with specified options
/// </summary>
/// <param name="options">Video Media Options</param>
/// <returns>Media file of new video or null if canceled</returns>
public async Task <MediaFile> TakeVideoAsync(StoreVideoOptions options)
{
if (!initialized)
{
await Initialize();
}
if (!IsCameraAvailable)
{
throw new NotSupportedException();
}
options.VerifyOptions();
var capture = new CameraCaptureUI();
var result = await capture.CaptureFileAsync(CameraCaptureUIMode.Video, options);
if (result == null)
{
return(null);
}
StorageFolder folder = ApplicationData.Current.LocalFolder;
string 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);
string filename = Path.GetFileName(path);
string aPath = null;
if (options?.SaveToAlbum ?? false)
{
try
{
string fileNameNoEx = Path.GetFileNameWithoutExtension(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);
}
}
var file = await result.CopyAsync(folder, filename, NameCollisionOption.GenerateUniqueName).AsTask();
return(new MediaFile(file.Path, () => file.OpenStreamForReadAsync().Result, albumPath: aPath));
}
public static async Task <MediaFile> TakeVideoAsync()
{
var options = new StoreVideoOptions();
options.Directory = "Fanword";
options.Name = $"{Guid.NewGuid()}.mp4";
options.PhotoSize = PhotoSize.Large;
return(await CrossMedia.Current.TakeVideoAsync(options));
}
public async Task <MediaFile> TakeVideoAsync(StoreVideoOptions options)
{
if (IsInitialize && IsSupported && IsTakeVideoSupported)
{
return(await CrossMedia.Current.TakeVideoAsync(options));
}
throw new System.NotImplementedException("No Permission");
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public Intent GetTakeVideoUI(StoreVideoOptions options)
{
if (!IsCameraAvailable)
throw new NotSupportedException();
VerifyOptions(options);
return CreateMediaIntent(GetRequestId(), "video/*", MediaStore.ActionVideoCapture, options, tasked: false);
}
/// <summary>
/// Take a video with specified options
/// </summary>
/// <param name="options">Video Media Options</param>
/// <returns>Media file of new video or null if canceled</returns>
public Task <Media.Plugin.Abstractions.MediaFile> TakeVideoAsync(StoreVideoOptions options)
{
if (!IsCameraAvailable)
{
throw new NotSupportedException();
}
VerifyOptions(options);
return(TakeMediaAsync("video/*", MediaStore.ActionVideoCapture, options));
}
/// <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));
}
/// <summary>
/// Take a video with specified options
/// </summary>
/// <param name="options">Video Media Options</param>
/// <returns>Media file of new video or null if canceled</returns>
public async Task<MediaFile> TakeVideoAsync(StoreVideoOptions options)
{
if (!IsCameraAvailable)
throw new NotSupportedException();
if (!(await RequestCameraPermission().ConfigureAwait(false)))
{
return null;
}
VerifyOptions(options);
return await TakeMediaAsync("video/*", MediaStore.ActionVideoCapture, options);
}
protected void OnTakeVideoButtonClicked(object sender, EventArgs args)
{
Debug.WriteLine("OnTakeVideoButtonClicked");
var videoOptions = new StoreVideoOptions
{
Name = "MyVideo",
Directory = "Videos",
};
var file = CrossMedia.Current.TakeVideoAsync(videoOptions);
Debug.WriteLine("OnTakeVideoButtonClicked_Completed");
}
/// <summary>
/// Take a video with specified options
/// </summary>
/// <param name="options">Video Media Options</param>
/// <returns>Media file of new video or null if canceled</returns>
public Task <MediaFile> TakeVideoAsync(StoreVideoOptions options)
{
if (!IsTakeVideoSupported)
{
throw new NotSupportedException();
}
if (!IsCameraAvailable)
{
throw new NotSupportedException();
}
VerifyCameraOptions(options);
return(GetMediaAsync(UIImagePickerControllerSourceType.Camera, TypeMovie, options));
}
public async Task <MediaFile> TakeVideo()
{
if (cameraOK == PermissionStatus.Granted &&
storageOK == PermissionStatus.Granted &&
CrossMedia.Current.IsTakeVideoSupported)
{
var options = new StoreVideoOptions {
SaveToAlbum = true
};
var file = await CrossMedia.Current.TakeVideoAsync(options);
return(file);
}
return(null);
}
/// <summary>
/// Take a video with specified options
/// </summary>
/// <param name="options">Video Media Options</param>
/// <returns>Media file of new video or null if canceled</returns>
public async Task <MediaFile> TakeVideoAsync(StoreVideoOptions options)
{
if (!IsCameraAvailable)
{
throw new NotSupportedException();
}
if (!(await RequestStoragePermission()))
{
return(null);
}
VerifyOptions(options);
return(await TakeMediaAsync("video/*", MediaStore.ActionVideoCapture, options));
}
/// <summary>
/// Take a video with specified options
/// </summary>
/// <param name="options">Video Media Options</param>
/// <returns>Media file of new video or null if canceled</returns>
public async Task <MediaFile> TakeVideoAsync(StoreVideoOptions options, CancellationToken token = default(CancellationToken))
{
if (!IsCameraAvailable)
{
throw new NotSupportedException();
}
if (!(await RequestCameraPermissions()))
{
throw new MediaPermissionException(Permission.Camera);
}
VerifyOptions(options);
return(await TakeMediaAsync("video/*", MediaStore.ActionVideoCapture, options, token));
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public MediaPickerController GetTakeVideoUI(StoreVideoOptions options)
{
if (!IsTakeVideoSupported)
{
throw new NotSupportedException();
}
if (!IsCameraAvailable)
{
throw new NotSupportedException();
}
VerifyCameraOptions(options);
var d = new MediaPickerDelegate(null, UIImagePickerControllerSourceType.Camera, options);
return(SetupController(d, UIImagePickerControllerSourceType.Camera, TypeMovie, options));
}
/// <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 Task<MediaFile> TakeVideoAsync(StoreVideoOptions options, CancellationToken token = default(CancellationToken))
{
if (!IsCameraAvailable || !IsTakeVideoSupported)
{
Log.Error(LOG_TAG, "TakeVideo is not supported");
throw new NotSupportedException();
}
var appControl = new AppControl();
appControl.Operation = OPERATION_CREATE_CONTENT;
appControl.Mime = "video/3gp";
appControl.LaunchMode = AppControlLaunchMode.Group;
SetOptions(options, ref appControl);
var ntcs = new TaskCompletionSource<MediaFile>();
Interlocked.CompareExchange(ref completionSource, ntcs, null);
AppControl.SendLaunchRequest(appControl, AppControlReplyReceivedCallback);
return completionSource.Task;
}
/// <summary>
/// Take a video with specified options
/// </summary>
/// <param name="options">Video Media Options</param>
/// <returns>Media file of new video or null if canceled</returns>
public Task <MediaFile> TakeVideoAsync(StoreVideoOptions options)
{
if (!IsCameraAvailable)
{
throw new NotSupportedException();
}
AppControl appControl = new AppControl();
appControl.Operation = OPERATION_CREATE_CONTENT;
appControl.Mime = "video/3gp";
appControl.LaunchMode = AppControlLaunchMode.Group;
SetOptions(options, ref appControl);
var ntcs = new TaskCompletionSource <MediaFile>();
Interlocked.CompareExchange(ref completionSource, ntcs, null);
AppControl.SendLaunchRequest(appControl, AppControlReplyReceivedCallback);
return(completionSource.Task);
}
/// <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));
}
private static MediaPickerController SetupController(MediaPickerDelegate mpDelegate, UIImagePickerControllerSourceType sourceType, string mediaType, StoreCameraMediaOptions options = null)
{
var picker = new MediaPickerController(mpDelegate);
picker.MediaTypes = new[] { mediaType };
picker.SourceType = sourceType;
if (sourceType == UIImagePickerControllerSourceType.Camera)
{
picker.CameraDevice = GetUICameraDevice(options.DefaultCamera);
picker.CameraFlashMode = GetUICameraFlashMode(options.FlashMode);
picker.AllowsEditing = options?.AllowCropping ?? false;
if (options.OverlayViewProvider != null)
{
var overlay = options.OverlayViewProvider();
if (overlay is UIView)
{
picker.CameraOverlayView = overlay as UIView;
}
}
if (mediaType == TypeImage)
{
picker.CameraCaptureMode = UIImagePickerControllerCameraCaptureMode.Photo;
}
else if (mediaType == TypeMovie)
{
StoreVideoOptions voptions = (StoreVideoOptions)options;
picker.CameraCaptureMode = UIImagePickerControllerCameraCaptureMode.Video;
picker.VideoQuality = GetQuailty(voptions.Quality);
picker.VideoMaximumDuration = voptions.DesiredLength.TotalSeconds;
}
}
return(picker);
}
/// <summary>
/// Take a video with specified options
/// </summary>
/// <param name="options">Video Media Options</param>
/// <returns>Media file of new video or null if canceled</returns>
public async Task <MediaFile> TakeVideoAsync(StoreVideoOptions options)
{
if (!IsCameraAvailable)
{
throw new NotSupportedException();
}
options.VerifyOptions();
var capture = new CameraCaptureUI();
capture.VideoSettings.MaxResolution = GetResolutionFromQuality(options.Quality);
capture.VideoSettings.MaxDurationInSeconds = (float)options.DesiredLength.TotalSeconds;
capture.VideoSettings.Format = CameraCaptureUIVideoFormat.Mp4;
var result = await capture.CaptureFileAsync(CameraCaptureUIMode.Video);
if (result == null)
{
return(null);
}
return(new MediaFile(result.Path, () => result.OpenStreamForReadAsync().Result));
}
/// <summary>
/// Take a video with specified options
/// </summary>
/// <param name="options">Video Media Options</param>
/// <returns>Media file of new video or null if canceled</returns>
public async Task <MediaFile> TakeVideoAsync(StoreVideoOptions options)
{
Console.WriteLine($"save: {options.SaveToAlbum}\nsize: {options.PhotoSize}\n");
if (!IsCameraAvailable)
{
throw new NotSupportedException();
}
if (!(await RequestCameraPermissions()))
{
return(null);
}
VerifyOptions(options);
var mediaList = await TakeMediaAsync("video/*", MediaStore.ActionVideoCapture, options);
if (mediaList == null)
{
return(null);
}
var media = mediaList.First();
if (string.IsNullOrWhiteSpace(media?.Path))
{
return(media);
}
media.Type = Abstractions.MediaType.Video;
if (options.SaveToAlbum)
{
SaveMediaToAlbum(options, media);
}
return(media);
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
Plugin.CurrentActivity.CrossCurrentActivity.Current.Init(this, bundle);
// Get our button from the layout resource,
// and attach an event to it
var button = FindViewById <Button>(Resource.Id.MyButton);
var image = FindViewById <ImageView>(Resource.Id.imageView1);
var switchSize = FindViewById <Switch>(Resource.Id.switch_size);
var switchSaveToAlbum = FindViewById <Switch>(Resource.Id.switch_save_album);
var switchCamera = FindViewById <Switch>(Resource.Id.switch_front);
var switchCancel = FindViewById <Switch>(Resource.Id.switch_cancel);
button.Click += async delegate
{
try
{
var cts = new CancellationTokenSource();
if (switchCancel.Checked)
{
cts.CancelAfter(TimeSpan.FromSeconds(10));
}
var size = switchSize.Checked ? PhotoSize.Medium : PhotoSize.Full;
var media = new MediaImplementation();
var file = await CrossMedia.Current.TakePhotoAsync(new StoreCameraMediaOptions
{
Directory = "Sample",
Name = $"{DateTime.Now}_{size}|\\?*<\":>/'.jpg".Replace(" ", string.Empty),
SaveToAlbum = switchSaveToAlbum.Checked,
PhotoSize = switchSize.Checked ? PhotoSize.Small : PhotoSize.Full,
DefaultCamera = switchCamera.Checked ? CameraDevice.Front : CameraDevice.Rear
}, cts.Token);
if (file == null)
{
return;
}
var path = file.Path;
Toast.MakeText(this, path, ToastLength.Long).Show();
System.Diagnostics.Debug.WriteLine(path);
var bitmap = BitmapFactory.DecodeFile(file.Path);
image.SetImageBitmap(bitmap);
file.Dispose();
}
catch (Exception ex)
{
Toast.MakeText(this, ex.Message, ToastLength.Long).Show();
}
};
var pick = FindViewById <Button>(Resource.Id.button1);
pick.Click += async(sender, args) =>
{
try
{
var cts = new CancellationTokenSource();
if (switchCancel.Checked)
{
cts.CancelAfter(TimeSpan.FromSeconds(10));
}
var file = await CrossMedia.Current.PickPhotoAsync(new PickMediaOptions
{
PhotoSize = switchSize.Checked ? PhotoSize.Large : PhotoSize.Full
}, cts.Token);
if (file == null)
{
return;
}
var path = file.Path;
Toast.MakeText(this, path, ToastLength.Long).Show();
System.Diagnostics.Debug.WriteLine(path);
var bitmap = BitmapFactory.DecodeFile(file.Path);
image.SetImageBitmap(bitmap);
file.Dispose();
}
catch (Exception ex)
{
Toast.MakeText(this, ex.Message, ToastLength.Long).Show();
}
};
FindViewById <Button>(Resource.Id.button2).Click += async(sender, args) =>
{
try
{
var cts = new CancellationTokenSource();
if (switchCancel.Checked)
{
cts.CancelAfter(TimeSpan.FromSeconds(10));
}
var size = switchSize.Checked ? VideoQuality.Low : VideoQuality.Medium;
var media = new MediaImplementation();
/*var options = new Plugin.Media.Abstractions.StoreVideoOptions
* {
* Directory = "Sample",
* Name = $"{DateTime.UtcNow}_{size}|\\?*<\":>/'.mp4".Replace(" ", string.Empty),
* SaveToAlbum = switchSaveToAlbum.Checked,
* Quality = size,
* DefaultCamera = switchCamera.Checked ? Plugin.Media.Abstractions.CameraDevice.Front : CameraDevice.Rear
* };*/
var options = new StoreVideoOptions
{
Directory = "HCS",
Name = $"{DateTime.UtcNow.ToString("yyyyMMddHHmmss")}.mp4",
SaveToAlbum = true,
Quality = VideoQuality.Medium,
DesiredSize = 45 * 1000000,
CompressionQuality = 0,
};
var file = await CrossMedia.Current.TakeVideoAsync(options, cts.Token);
if (file == null)
{
return;
}
var path = file.Path;
System.Diagnostics.Debug.WriteLine(path);
Toast.MakeText(this, path, ToastLength.Long).Show();
file.Dispose();
}
catch (Exception ex)
{
Toast.MakeText(this, ex.Message, ToastLength.Long).Show();
}
};
FindViewById <Button>(Resource.Id.button3).Click += async(sender, args) =>
{
var cts = new CancellationTokenSource();
if (switchCancel.Checked)
{
cts.CancelAfter(TimeSpan.FromSeconds(10));
}
var media = new MediaImplementation();
var file = await CrossMedia.Current.PickVideoAsync(cts.Token);
if (file == null)
{
return;
}
var path = file.Path;
Toast.MakeText(this, path, ToastLength.Long).Show();
System.Diagnostics.Debug.WriteLine(path);
file.Dispose();
};
}
/// <summary>
///
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public Task <MediaFile> TakeVideoAsync(StoreVideoOptions options)
{
return(Task.FromResult <MediaFile>(null));
}
/// <summary>
/// Take a video with specified options
/// </summary>
/// <param name="options">Video Media Options</param>
/// <returns>Media file of new video or null if canceled</returns>
public Task <MediaFile> TakeVideoAsync(StoreVideoOptions options)
{
throw new NotSupportedException();
}
public Task <MediaFile> TakeMediaAsync(StoreVideoOptions options)
{
throw new NotImplementedException();
}
public async Task <MediaFileResponse> TakeVideoAsync()
{
// https://github.com/jamesmontemagno/MediaPlugin
MediaFileResponse response = new MediaFileResponse();
MediaFile file = new MediaFile("", null);
// Initialize Camera
await CrossMedia.Current.Initialize();
// Check to see if camera is available
if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsTakeVideoSupported)
{
// If camera is not available
if (!CrossMedia.Current.IsPickVideoSupported)
{
response.IsSuccess = false;
response.Message = "Pick Video not supported";
}
// Pick from library or album if pick video is supported
else
{
file = await CrossMedia.Current.PickVideoAsync();
response.IsSuccess = true;
response.Message = string.Empty;
}
}
else
{
// Take video from camera
StoreVideoOptions videoOptions = new StoreVideoOptions
{
Directory = ApplicationSettingsConstant.VideoDirectory,
Name = $"{Guid.NewGuid()}.mp4",
SaveToAlbum = true,
AllowCropping = true,
DefaultCamera = CameraDevice.Rear,
DesiredLength = TimeSpan.FromMinutes(5),
Quality = VideoQuality.Medium
};
file = await CrossMedia.Current.TakeVideoAsync(videoOptions);
response.IsSuccess = true;
response.Message = string.Empty;
}
if (file != null)
{
//Get the public album path
response.AlbumPath = file.AlbumPath;
//Get private path
response.Path = file.Path;
response.Stream = file.GetStream();
// Disponse file
file.Dispose();
}
return(response);
}
private static MediaPickerController SetupCameraController(MediaPickerDelegate mpDelegate, StoreVideoOptions options)
{
var picker = new MediaPickerController(mpDelegate)
{
MediaTypes = new[] { TypeImage, TypeMovie },
SourceType = UIImagePickerControllerSourceType.Camera,
CameraDevice = GetUICameraDevice(options.DefaultCamera),
CameraCaptureMode = UIImagePickerControllerCameraCaptureMode.Photo,
AllowsEditing = options?.AllowCropping ?? false,
VideoQuality = GetQuailty(options.Quality),
VideoMaximumDuration = options.DesiredLength.TotalSeconds,
};
if (options.OverlayViewProvider != null)
{
var overlay = options.OverlayViewProvider();
if (overlay is UIView)
{
picker.CameraOverlayView = overlay as UIView;
}
}
return(picker);
}
