/// <param name="fileUrl">The URL for the file.</param> /// <param name="parentItemIdentifier">The parent directory's persistent identifier.</param> /// <param name="completionHandler">A handler to run after the operation completes.</param> /// <summary>When implemented by the developer, imports the resource at the specified <paramref name="fileUrl" /> into the directory that is identified by <paramref name="parentItemIdentifier" />.</summary> /// <remarks> /// <para>(More documentation for this node is coming)</para> /// <para tool="threads">This can be used from a background thread.</para> /// </remarks> public override void ImportDocument(NSUrl fileUrl, string parentItemIdentifier, Action <INSFileProviderItem, NSError> completionHandler) { try { fileUrl.StartAccessingSecurityScopedResource(); FolderMetadata parentMetadata = StorageManager.GetFolderMetadata(parentItemIdentifier); if (!parentMetadata.IsExists) { completionHandler?.Invoke(null, NSFileProviderErrorFactory.CreateNonExistentItemError(parentItemIdentifier)); return; } IEnumerable <string> existsNames = StorageManager.GetFolderChildrenMetadatas(parentMetadata).Select(x => x.Name); string fileName = GetNewFileName(fileUrl.LastPathComponent, existsNames); FileMetadata createdFile = StorageManager.CreateFileOnServer(parentMetadata, fileName); createdFile = StorageManager.WriteFileContentOnServer(createdFile, fileUrl.Path); completionHandler?.Invoke(ProviderItem.CreateFromMetadata(createdFile), null); this.StorageManager.NotifyEnumerator(parentItemIdentifier); } catch (Exception ex) { NSError error = this.MapError(ex); completionHandler?.Invoke(null, error); } finally { fileUrl.StopAccessingSecurityScopedResource(); } }
public void PickedDocument(NSUrl url) { url.StartAccessingSecurityScopedResource(); var doc = new UIDocument(url); var fileName = doc.LocalizedName; if (string.IsNullOrWhiteSpace(fileName)) { var path = doc.FileUrl?.ToString(); if (path != null) { path = WebUtility.UrlDecode(path); var split = path.LastIndexOf('/'); fileName = path.Substring(split + 1); } } var fileCoordinator = new NSFileCoordinator(); fileCoordinator.CoordinateRead(url, NSFileCoordinatorReadingOptions.WithoutChanges, out NSError error, (u) => { var data = NSData.FromUrl(u).ToArray(); SelectFileResult(data, fileName ?? "unknown_file_name"); }); url.StopAccessingSecurityScopedResource(); }
/// <summary> /// Get the archived data from a URL Path /// </summary> private void FetchArchivedWorldMap(NSUrl url, Action <NSData, NSError> closure) { DispatchQueue.DefaultGlobalQueue.DispatchAsync(() => { try { _ = url.StartAccessingSecurityScopedResource(); var data = NSData.FromUrl(url); closure(data, null); } catch { // TODO: //DispatchQueue.MainQueue.DispatchAsync(() => //{ // this.ShowAlert(error.LocalizedDescription); //}); //closure(null, error); } finally { url.StopAccessingSecurityScopedResource(); } }); }
void PrintOutsideFileContent(NSUrl securityScopedUrl) { if (!securityScopedUrl.StartAccessingSecurityScopedResource()) { return; } PrintFileContent(securityScopedUrl); securityScopedUrl.StopAccessingSecurityScopedResource(); }
internal UIDocumentFileResult(NSUrl url) : base() { url.StartAccessingSecurityScopedResource(); var doc = new UIDocument(url); FullPath = doc.FileUrl?.Path; FileName = doc.LocalizedName ?? Path.GetFileName(FullPath); // immediately open a file stream, in case iOS cleans up the picked file fileStream = File.OpenRead(FullPath); url.StopAccessingSecurityScopedResource(); }
FileData ParseUrl(NSUrl p_url) { p_url.StartAccessingSecurityScopedResource(); var doc = new UIDocument(p_url); string name = doc.LocalizedName; string path = doc.FileUrl?.Path; // iCloud drive can return null for LocalizedName. if (name == null && path != null) { name = Path.GetFileName(path); } var fd = new FileData(path, name, _fileManager.GetAttributes(path).Size.Value); p_url.StopAccessingSecurityScopedResource(); return(fd); }
internal BookmarkDataFileResult(NSUrl url) : base() { try { url.StartAccessingSecurityScopedResource(); var newBookmark = url.CreateBookmarkData(0, Array.Empty <string>(), null, out var bookmarkError); if (bookmarkError != null) { throw new NSErrorException(bookmarkError); } UpdateBookmark(url, newBookmark); } finally { url.StopAccessingSecurityScopedResource(); } }
public static IDisposable BeginScope(NSUrl url) { lock (_syncLock) { var absoluteString = url.AbsoluteString; if (!_activeScopes.TryGetValue(absoluteString, out var disposable) || disposable.IsDisposed) { bool scopeStarted = false; try { scopeStarted = url.StartAccessingSecurityScopedResource(); } catch (Exception ex) { throw new UnauthorizedAccessException("Could not access file system item. " + ex); } if (scopeStarted) { disposable = new RefCountDisposable(Disposable.Create(() => { lock (_syncLock) { url.StopAccessingSecurityScopedResource(); _activeScopes.Remove(absoluteString); } })); _activeScopes[absoluteString] = disposable; return(disposable); } else { return(Disposable.Empty); } } else { return(disposable.GetDisposable()); } } }
void PrintOutsideFileContent(NSUrl securityScopedUrl) { if (!securityScopedUrl.StartAccessingSecurityScopedResource ()) return; PrintFileContent (securityScopedUrl); securityScopedUrl.StopAccessingSecurityScopedResource (); }
public override bool OpenUrl(UIApplication app, NSUrl url, NSDictionary options) { Task.Run(async() => { if ("Inbox".Equals(Path.GetFileName(Path.GetDirectoryName(url.Path)))) { IFolder incoming = await App.Storage.CreateFolderAsync("Incoming", CreationCollisionOption.OpenIfExists); IFile f = await FileSystem.Current.GetFileFromPathAsync(url.Path); await f.MoveAsync(Path.Combine(incoming.Path, f.Name), NameCollisionOption.GenerateUniqueName); Xamarin.Forms.Device.BeginInvokeOnMainThread(async() => { App.MainTab.SelectedItem = App.MainTab.Children[3]; await App.MainTab.Children[3].Navigation.PopToRootAsync(); await App.MainTab.Children[3].Navigation.PushAsync(new FileBrowser(incoming)); }); } else if (url.Path?.EndsWith(".cb5") ?? false) { url.StartAccessingSecurityScopedResource(); try { //using (MemoryStream s = new MemoryStream()) { // NSInputStream stream = NSInputStream.FromUrl(url); // byte[] buffer = new byte[1024]; // while (stream.HasBytesAvailable()) { // int read = (int)stream.Read(buffer, 1024); // s.Write(buffer, 0, read); // } // s.Seek(0, SeekOrigin.Begin); //NSFileHandle fs = NSFileHandle.OpenReadUrl(url, out NSError err); //NSData data = fs.ReadDataToEndOfFile(); //fs.CloseFile(); //using (Stream f = data.AsStream()) {AsStream //new MyInputStream(NSInputStream.FromUrl(url))) { //NSData d = await url.LoadDataAsync("text/xml"); //File.OpenRead(url.Path) using (Stream s = File.OpenRead(url.Path)) { Player player = Player.Serializer.Deserialize(s) as Player; BuilderContext Context = new BuilderContext(player); PluginManager manager = new PluginManager(); manager.Add(new SpellPoints()); manager.Add(new SingleLanguage()); manager.Add(new CustomBackground()); manager.Add(new NoFreeEquipment()); Context.Plugins = manager; Context.UndoBuffer = new LinkedList <Player>(); Context.RedoBuffer = new LinkedList <Player>(); Context.UnsavedChanges = 0; Xamarin.Forms.Device.BeginInvokeOnMainThread(async() => { LoadingProgress loader = new LoadingProgress(Context); LoadingPage l = new LoadingPage(loader, false); App.MainTab.SelectedItem = App.MainTab.Children[1]; await App.MainTab.Children[2].Navigation.PushModalAsync(l); var t = l.Cancel.Token; try { await loader.Load(t).ConfigureAwait(false); t.ThrowIfCancellationRequested(); PlayerBuildModel model = new PlayerBuildModel(Context); Xamarin.Forms.Device.BeginInvokeOnMainThread(async() => { await App.MainTab.Children[1].Navigation.PopModalAsync(false); await App.MainTab.Children[1].Navigation.PushModalAsync(new NavigationPage(new FlowPage(model))); }); } catch (Exception e) { ConfigManager.LogError(e); } }); } url.StopAccessingSecurityScopedResource(); } catch (Exception e) { ConfigManager.LogError(e); } } else if (url.Path.StartsWith(App.Storage.Path, System.StringComparison.Ordinal)) { Xamarin.Forms.Device.BeginInvokeOnMainThread(async() => { App.MainTab.SelectedItem = App.MainTab.Children[3]; await App.MainTab.Children[3].Navigation.PopToRootAsync(); await App.MainTab.Children[3].Navigation.PushAsync(new FileBrowser(await FileSystem.Current.GetFolderFromPathAsync(Path.GetDirectoryName(url.Path)))); }); } else { url.StartAccessingSecurityScopedResource(); IFolder incoming = await App.Storage.CreateFolderAsync("Incoming", CreationCollisionOption.OpenIfExists); IFile target = await incoming.CreateFileAsync(url.LastPathComponent, CreationCollisionOption.GenerateUniqueName); using (Stream f = File.OpenRead(url.Path)) { using (Stream o = await target.OpenAsync(PCLStorage.FileAccess.ReadAndWrite)) { await f.CopyToAsync(o); } } url.StopAccessingSecurityScopedResource(); Xamarin.Forms.Device.BeginInvokeOnMainThread(async() => { App.MainTab.SelectedItem = App.MainTab.Children[3]; await App.MainTab.Children[3].Navigation.PopToRootAsync(); await App.MainTab.Children[3].Navigation.PushAsync(new FileBrowser(incoming)); }); } }).Forget(); return(true); }