public override string GetMimeType(string path)
{
string extension = NSUrl.FromString(path).PathExtension;
string uniformTypeIdentifier = UTType.CreatePreferredIdentifier(UTType.TagClassFilenameExtension, extension, null);
return(UTType.GetPreferredTag(uniformTypeIdentifier, UTType.TagClassMIMEType));
}
internal static string PlatformGetContentType(string extension)
{
// ios does not like the extensions
extension = extension?.TrimStart('.');
var id = UTType.CreatePreferredIdentifier(UTType.TagClassFilenameExtension, extension, null);
var mimeTypes = UTType.CopyAllTags(id, UTType.TagClassMIMEType);
return(mimeTypes.Length > 0 ? mimeTypes[0] : null);
}
public void CreatePreferredIdentifier()
{
string[] extensions = new [] { ".html", ".css", ".jpg", ".js", ".otf" };
// random failure reported in #36708 (on some iPad2 only)
for (int i = 0; i < 100; i++)
{
foreach (var ext in extensions)
{
var result = UTType.CreatePreferredIdentifier(UTType.TagClassMIMEType, ext, null);
Assert.NotNull(result, ext + i.ToString());
}
}
}
public static NSString ToNsUti(this string mimeType)
{
var uuType = UTType.CreatePreferredIdentifier(UTType.TagClassMIMEType, mimeType.ToLower(), null);
if (mimeType == "text/url")
{
if (mimeType.StartsWith("file://", StringComparison.InvariantCultureIgnoreCase))
{
return(UTType.FileURL);
}
return(UTType.URL);
}
//var uuType = UTType.CreatePreferredIdentifier(UTType.TagClassMIMEType, mimeType.ToLower(), null);
return(new NSString(uuType));
}
public void CreatePreferredIdentifier()
{
// This test may fail in the simulator, if the architecture of the simulator isn't the native one (say running x86_64 on an M1 machine),
// so just skip this test for the simulator.
TestRuntime.AssertIfSimulatorThenARM64();
string[] extensions = new [] { ".html", ".css", ".jpg", ".js", ".otf" };
// random failure reported in #36708 (on some iPad2 only)
for (int i = 0; i < 100; i++)
{
foreach (var ext in extensions)
{
var result = UTType.CreatePreferredIdentifier(UTType.TagClassMIMEType, ext, null);
Assert.NotNull(result, ext + i.ToString());
}
}
}
private void HandleImage(IEnumerable <PHObject> images)
{
foreach (PHAsset image in images)
{
if (image.MediaType == PHAssetMediaType.Image)
{
PHImageRequestOptions options = new PHImageRequestOptions()
{
NetworkAccessAllowed = false,
ResizeMode = PHImageRequestOptionsResizeMode.Exact,
Version = PHImageRequestOptionsVersion.Original
};
PHImageManager.DefaultManager.RequestImageData(image, options, async(d, t, o, i) =>
{
string path = ((NSUrl)i["PHImageFileURLKey"])?.Path;
string mimeType = UTType.GetPreferredTag(t, UTType.TagClassMIMEType);
await _probe.CreateAndStoreDatumAsync(path, mimeType, (DateTime)image.CreationDate);
});
}
else if (image.MediaType == PHAssetMediaType.Video)
{
PHVideoRequestOptions options = new PHVideoRequestOptions()
{
NetworkAccessAllowed = false,
Version = PHVideoRequestOptionsVersion.Original
};
PHImageManager.DefaultManager.RequestAvAsset(image, options, async(a, _, i) =>
{
if (a is AVUrlAsset urlAsset)
{
string path = urlAsset.Url.Path;
string extension = urlAsset.Url.PathExtension;
string uniformTypeIdentifier = UTType.CreatePreferredIdentifier(UTType.TagClassFilenameExtension, extension, null);
string mimeType = UTType.GetPreferredTag(uniformTypeIdentifier, UTType.TagClassMIMEType);
await _probe.CreateAndStoreDatumAsync(path, mimeType, (DateTime)image.CreationDate);
}
});
}
}
}
public string GetMimeType(string fileUriOrExt)
{
if (String.IsNullOrWhiteSpace(fileUriOrExt))
{
return(null);
}
string extension = Path.GetExtension(fileUriOrExt);
if (extension == null)
{
return(null);
}
var uti = UTType.CreatePreferredIdentifier(UTType.TagClassFilenameExtension, extension.Substring(1), null);
var mimeType = UTType.GetPreferredTag(uti, UTType.TagClassMIMEType);
return(mimeType);
}
public Tuple <byte[], string, string> ReadFile(string file)
{
Tuple <byte[], string, string> result = null;
var asset = PHAsset.FetchAssets(new[] { new NSUrl(file) }, null).LastObject as PHAsset;
if (asset != null)
{
var options = new PHImageRequestOptions {
Synchronous = true
};
PHImageManager.DefaultManager.RequestImageData(asset, options, (data, dataUti, orientation, info) => {
var extension = new NSUrl(dataUti).PathExtension;
var uti = UTType.CreatePreferredIdentifier(UTType.TagClassFilenameExtension, extension, null);
var mime = UTType.GetPreferredTag(uti, UTType.TagClassMIMEType);
var dataBytes = new byte[data.Length];
Marshal.Copy(data.Bytes, dataBytes, 0, Convert.ToInt32(data.Length));
result = new Tuple <byte[], string, string>(dataBytes, dataUti, mime);
});
}
return(result);
}
public async Task <ToastImageSource> FromUriAsync(Uri uri, CancellationToken cancellationToken = default)
{
string contentType = "";
var fullFn = await imageCacher.CacheAsync(uriToFileNameStrategy.Convert(uri), cancellationToken, async (stream, ct) =>
{
var hc = httpClientFactory.CreateClient(nameof(IToastImageSourceFactory));
using (var response = await hc.GetAsync(uri))
{
contentType = response.Content.Headers.ContentType.MediaType;
using (var src = await response.Content.ReadAsStreamAsync())
await src.CopyToAsync(stream, 1024 * 80, cancellationToken);
}
});
if (string.IsNullOrEmpty(contentType))
{
using (var fs = File.OpenRead(fullFn))
contentType = await mimeDetector.DetectAsync(fs);
}
return(new SealedToastImageSource(CreateAttachment(uri.ToString(), NSUrl.FromFilename(fullFn),
UTType.CreatePreferredIdentifier(UTType.TagClassMIMEType, contentType, null))));
}
/// <summary>
/// File picking implementation
/// </summary>
/// <param name="allowedTypes">list of allowed file extention types; may be null</param>
/// <returns>picked file data, or null when picking was cancelled</returns>
private Task <FileData> PickMediaAsync(string[] allowedTypes)
{
var id = this.GetRequestId();
var ntcs = new TaskCompletionSource <FileData>(id);
if (Interlocked.CompareExchange(ref this.completionSource, ntcs, null) != null)
{
throw new InvalidOperationException("Only one operation can be active at a time");
}
var allowedUtis = new string[]
{
UTType.Content,
UTType.Item,
"public.data"
};
if (allowedTypes != null)
{
List <string> typeslist = new List <string>();
foreach (var extension in allowedTypes)
{
if (!string.IsNullOrEmpty(extension))
{
var fixed_Extension = extension?.TrimStart('.');
// get the UTI for an extension
//var uti = UTType.CreatePreferredIdentifier(UTType.TagClassFilenameExtension, fixed_Extension, null);
// "public.jpeg"
// get the UTI for a MIME type
//var uti2 = UTType.CreatePreferredIdentifier(UTType.TagClassMIMEType, fixed_Extension, null);
// "com.adobe.pdf"
// get the MIME type for a UTI
//var mime = UTType.GetPreferredTag(uti, UTType.TagClassFilenameExtension);
var UTid = UTType.CreatePreferredIdentifier(UTType.TagClassFilenameExtension, fixed_Extension, null);
typeslist.Add(UTid);
}
}
allowedUtis = typeslist.ToArray();
}
// NOTE: Importing (UIDocumentPickerMode.Import) makes a local copy of the document,
// while opening (UIDocumentPickerMode.Open) opens the document directly. We do the
// first, so the user has to read the file immediately.
var documentPicker = new UIDocumentPickerViewController(allowedUtis, UIDocumentPickerMode.Import);
documentPicker.ModalPresentationStyle = UIModalPresentationStyle.FullScreen;
documentPicker.DidPickDocument += this.DocumentPicker_DidPickDocument;
documentPicker.WasCancelled += this.DocumentPicker_WasCancelled;
documentPicker.DidPickDocumentAtUrls += this.DocumentPicker_DidPickDocumentAtUrls;
UIViewController viewController = GetActiveViewController();
viewController.PresentViewController(documentPicker, true, null);
this.Handler = (sender, args) =>
{
var tcs = Interlocked.Exchange(ref this.completionSource, null);
tcs?.SetResult(new FileData(
args.FilePath,
args.FileName,
() => GetStreamFromPath(args.FilePath).Result));
};
return(this.completionSource.Task);
}
protected string CreateDynamicTypeFor(string type)
{
return(UTType.CreatePreferredIdentifier(UTType.kUTTagClassNSPboardType, Pasteboard.NSPasteboardTypeWebArchive, UTType.kUTTypeData));
}
public string GetFileType(string extension) => UTType.CreatePreferredIdentifier(UTType.TagClassFilenameExtension, extension, null);
private bool CanConformsToImageUTI(NSString url)
{
var uti = UTType.CreatePreferredIdentifier(UTType.TagClassFilenameExtension, url.PathExtension, null);
return(UTType.ConformsTo(uti, UTType.Image));
}