///<inheritdoc/>
public async Task <IList <ImageFile> > GetFilesFromFolderAsync(string folderPath)
{
folderPath = Path.GetDirectoryName(folderPath);
StorageFolder targetStorageFolder = null;
try
{
targetStorageFolder = await StorageFolder.GetFolderFromPathAsync(folderPath);
}
catch (UnauthorizedAccessException e)
{
throw new Contract.Exceptions.UnauthorizedAccessException(e);
}
var storageFiles = (await targetStorageFolder.GetFilesAsync());
List <ImageFile> imageFiles = new List <ImageFile>();
foreach (var item in storageFiles)
{
if (FileTypeFilter.Contains(item.FileType.ToLower()))
{
imageFiles.Add(await FileToImageFileAsync(item, false));
}
}
return(imageFiles);
}
private NativeFilePickerAcceptType[] BuildFileTypesMap()
{
var allExtensions = FileTypeFilter.Except(new[] { "*" });
var acceptTypes = allExtensions
.Select(fileType => BuildNativeFilePickerAcceptType(fileType))
.ToList();
if (!FileTypeFilter.Contains("*"))
{
var fullAcceptItem = new NativeFilePickerAcceptTypeItem
{
MimeType = "*/*",
Extensions = allExtensions.ToArray()
};
var fullAcceptType = new NativeFilePickerAcceptType()
{
Description = "All files",
Accept = new[] { fullAcceptItem }
};
acceptTypes.Insert(0, fullAcceptType);
}
return(acceptTypes.ToArray());
}
private string[] GetMimeTypes()
{
if (FileTypeFilter.Contains("*"))
{
return(new[] { "*/*" });
}
return(FileTypeFilter
.Select(extension => MimeTypeService.GetFromExtension(extension))
.Distinct()
.ToArray());
}
private async Task <FilePickerSelectedFilesArray> NativePickerPickFilesAsync(bool multiple, CancellationToken token)
{
var showAllEntryParameter = FileTypeFilter.Contains("*") ? "true" : "false";
var multipleParameter = multiple ? "true" : "false";
var fileTypeAcceptTypes = BuildFileTypesMap();
var fileTypeAcceptTypesJson = JsonHelper.Serialize(fileTypeAcceptTypes);
var fileTypeMapParameter = WebAssemblyRuntime.EscapeJs(fileTypeAcceptTypesJson);
var nativeStorageItemInfosJson = await WebAssemblyRuntime.InvokeAsync($"{JsType}.nativePickFilesAsync({multipleParameter},{showAllEntryParameter},'{fileTypeMapParameter}')");
var infos = JsonHelper.Deserialize <NativeStorageItemInfo[]>(nativeStorageItemInfosJson);
var results = new List <StorageFile>();
foreach (var info in infos)
{
var storageFile = StorageFile.GetFromNativeInfo(info);
results.Add(storageFile);
}
return(new FilePickerSelectedFilesArray(results.ToArray()));
}
private FilePickerSelectedFilesArray PickFiles(bool pickMultiple, CancellationToken token)
{
var openPanel = new NSOpenPanel
{
CanChooseFiles = true,
CanChooseDirectories = false,
AllowsMultipleSelection = pickMultiple,
AllowsOtherFileTypes = FileTypeFilter.Contains("*")
};
if (!openPanel.AllowsOtherFileTypes)
{
var fileTypes = GetFileTypes();
openPanel.AllowedFileTypes = fileTypes;
}
if (!string.IsNullOrEmpty(CommitButtonText))
{
openPanel.Prompt = CommitButtonText;
}
var result = openPanel.RunModal();
if (result == ModalResponseOk)
{
if (openPanel.Urls != null)
{
var files = openPanel.Urls
.Where(url => url?.Path != null)
.Select(url => StorageFile.GetFileFromPath(url.Path))
.ToArray();
return(new FilePickerSelectedFilesArray(files));
}
}
return(FilePickerSelectedFilesArray.Empty);
}
private string[] GetMimeTypes()
{
if (FileTypeFilter.Contains("*"))
{
return(new[] { "*/*" });
}
List <string> mimeTypes = new List <string>();
using Android.Webkit.MimeTypeMap? mimeTypeMap = Android.Webkit.MimeTypeMap.Singleton;
if (mimeTypeMap is null)
{
// when map is unavailable (probably never happens, but Singleton returns nullable)
return(new[] { "*/*" });
}
foreach (string oneExtensionForLoop in FileTypeFilter)
{
bool unknownExtensionPresent = false;
string oneExtension = oneExtensionForLoop;
if (oneExtension.StartsWith("."))
{
// Supported format from UWP, e.g. ".jpg"
oneExtension = oneExtension.Substring(1);
}
if (!mimeTypeMap.HasExtension(oneExtension))
{
// when there is unknown extension, we should show all files
unknownExtensionPresent = true;
}
string?mimeType = mimeTypeMap.GetMimeTypeFromExtension(oneExtension);
if (string.IsNullOrEmpty(mimeType))
{
// second check for unknown extension...
unknownExtensionPresent = true;
}
else
{
#pragma warning disable CS8604 // Possible null reference argument.
// it cannot be null, as this is within "if", but still compiler complains about possible null reference
if (!mimeTypes.Contains(mimeType))
{
mimeTypes.Add(mimeType);
}
#pragma warning restore CS8604 // Possible null reference argument.
}
if (unknownExtensionPresent)
{
// it is some unknown extension
var mimeTypesFromUno = FileTypeFilter
.Select(extension => MimeTypeService.GetFromExtension(extension))
.Distinct();
if (mimeTypesFromUno is null || mimeTypesFromUno.Count() < 1)
{
return(new[] { "*/*" });
}
foreach (var oneUnoMimeType in mimeTypesFromUno)
{
if (!mimeTypes.Contains(oneUnoMimeType))
{
mimeTypes.Add(oneUnoMimeType);
}
}
}
}
return(mimeTypes.ToArray());
}
