Xamarin. iOS içinde belge seçici

Belge seçici, belgelerin uygulamalar arasında paylaşılmasını sağlar. Bu belgeler iCloud içinde veya farklı bir uygulama dizininde depolanabilir. Belgeler, kullanıcının cihazına yüklediği belge sağlayıcısı uzantıları kümesi aracılığıyla paylaşılır.

Belgeleri uygulamalar ve bulut arasında eşitlenmiş halde tutmanın zorluğunu ortadan kaldırın.

Gereksinimler

Bu makalede sunulan adımları gerçekleştirmek için aşağıdakiler gereklidir:

• Xcode 7 ve iOS 8 veya daha yeni – Apple 'ın Xcode 7 ve iOS 8 ya da daha yeni API 'lerinin geliştiricinin bilgisayarında yüklü ve yapılandırılmış olması gerekir.
• Visual Studio veya Mac için Visual Studio – en son Mac için Visual Studio sürümü yüklenmelidir.
• IOS cihazı : iOS 8 veya üstünü çalıştıran bir iOS aygıtıdır.

İCloud 'a yapılan değişiklikler

Belge seçicisinin yeni özelliklerini uygulamak için Apple 'ın iCloud hizmetinde aşağıdaki değişiklikler yapılmıştır:

• İCloud Daemon, CloudKit kullanılarak tamamen yeniden yazıldı.
• Mevcut iCloud özellikleri iCloud Drive olarak yeniden adlandırıldı.
• iCloud 'a Microsoft Windows OS desteği eklenmiştir.
• Mac OS Finder 'a bir iCloud klasörü eklenmiştir.
• iOS cihazları Mac OS iCloud klasörünün içeriğine erişebilir.

Belge nedir?

İCloud 'daki bir belgeye başvuru yaparken, tek bir tek başına varlıktır ve Kullanıcı tarafından bu şekilde algılanır. Bir Kullanıcı belgeyi değiştirmek veya başka kullanıcılarla paylaşmak isteyebilir (örneğin, e-posta kullanarak).

Kullanıcının sayfalar, Keynote veya sayı dosyaları gibi bir belge olarak hemen tanıyacağı birkaç tür dosya vardır. Ancak iCloud bu kavram ile sınırlı değildir. Örneğin, bir oyunun durumu (satranç eşleşme gibi) bir belge olarak kabul edilebilir ve iCloud 'da depolanabilir. Bu dosya, bir kullanıcının aygıtları arasında geçirilebilir ve farklı bir cihazda bıraktığınız bir oyun seçmesine izin veriyor.

Belgelerle ilgilenme

Belge seçiciyi Xamarin ile kullanmak için gereken koda girmeden önce, bu makale iCloud belgeleriyle çalışmaya yönelik en iyi yöntemleri ve belge seçiciyi desteklemek için gereken mevcut API 'Lerde yapılan değişiklikleri kapsar.

Dosya koordinasyonu kullanma

Bir dosya birkaç farklı konumdan değiştirilebildiğinden, veri kaybını engellemek için koordinasyon kullanılması gerekir.

Yukarıdaki çizime göz atalım:

1. Dosya düzenlemesi kullanan bir iOS cihazı yeni bir belge oluşturur ve iCloud klasörüne kaydeder.
2. iCloud, değiştirilen dosyayı her cihaza dağıtım için buluta kaydeder.
3. Eklenmiş bir Mac, iCloud klasöründe değiştirilmiş dosyayı görür ve dosyadaki değişiklikleri kopyalamak için dosya koordinasyonunu kullanır.
4. Dosya düzenlemesi kullanmayan bir cihaz dosyada değişiklik yapar ve iCloud klasörüne kaydeder. Bu değişiklikler, diğer cihazlara anında çoğaltılır.

Özgün iOS cihazını veya Mac 'in dosyayı düzenlemiş olduğunu varsayıyoruz, artık değişikliklerinin kayıp ve dosyanın üzerine, geri alındığı cihazdan dosyanın sürümüyle üzerine yazılır. Veri kaybını engellemek için, bulut tabanlı belgelerle çalışırken dosya koordinasyonu bir olmalıdır.

Uıdocument kullanma

UIDocumentNSDocumentGeliştirici için tüm ağır hırsızlığı yaparak şeyleri basit (veya macOS 'ta) hale getirir. Uygulamanın kullanıcı arabirimini engellemeye devam etmek için arka plan kuyruklarında yerleşik dosya düzenlemesi sağlar.

UIDocument bir Xamarin uygulamasının geliştirme çabasında geliştiricilerin gerektirdiği herhangi bir amaçla kolaylaştırılmasına olanak tanıyan birden çok, üst düzey API sunar.

Aşağıdaki kod, UIDocument iCloud 'dan metin depolamak ve almak için kullanılabilecek genel metin tabanlı bir belge uygulamak için öğesinin bir alt sınıfını oluşturur:

using System;
using Foundation;
using UIKit;

namespace DocPicker
{
    public class GenericTextDocument : UIDocument
    {
        #region Private Variable Storage
        private NSString _dataModel;
        #endregion

        #region Computed Properties
        public string Contents {
            get { return _dataModel.ToString (); }
            set { _dataModel = new NSString(value); }
        }
        #endregion

        #region Constructors
        public GenericTextDocument (NSUrl url) : base (url)
        {
            // Set the default document text
            this.Contents = "";
        }

        public GenericTextDocument (NSUrl url, string contents) : base (url)
        {
            // Set the default document text
            this.Contents = contents;
        }
        #endregion

        #region Override Methods
        public override bool LoadFromContents (NSObject contents, string typeName, out NSError outError)
        {
            // Clear the error state
            outError = null;

            // Were any contents passed to the document?
            if (contents != null) {
                _dataModel = NSString.FromData( (NSData)contents, NSStringEncoding.UTF8 );
            }

            // Inform caller that the document has been modified
            RaiseDocumentModified (this);

            // Return success
            return true;
        }

        public override NSObject ContentsForType (string typeName, out NSError outError)
        {
            // Clear the error state
            outError = null;

            // Convert the contents to a NSData object and return it
            NSData docData = _dataModel.Encode(NSStringEncoding.UTF8);
            return docData;
        }
        #endregion

        #region Events
        public delegate void DocumentModifiedDelegate(GenericTextDocument document);
        public event DocumentModifiedDelegate DocumentModified;

        internal void RaiseDocumentModified(GenericTextDocument document) {
            // Inform caller
            if (this.DocumentModified != null) {
                this.DocumentModified (document);
            }
        }
        #endregion
    }
}

GenericTextDocumentYukarıda sunulan sınıf, bir Xamarin. iOS 8 uygulamasında belge seçiciyle ve dış belgelerle çalışırken bu makale boyunca kullanılacaktır.

Zaman uyumsuz dosya düzenlemesi

iOS 8 yeni dosya düzenleme API 'Leri aracılığıyla birkaç yeni zaman uyumsuz dosya koordinasyon özelliği sağlar. İOS 8 ' den önce tüm mevcut dosya koordinasyon API 'Leri tamamen zaman uyumludur. Bu, geliştiricinin uygulamanın kullanıcı arabirimini engellemesini engellemek için kendi arka plan kuyruğu uygulamaktan sorumludur.

Yeni NSFileAccessIntent sınıf, dosyaya işaret eden BIR URL ve gereken koordinasyon türünü denetlemek için çeşitli seçenekleri içerir. Aşağıdaki kod, amaçları kullanarak bir dosyanın bir konumdan diğerine taşınmasını göstermektedir:

// Get source options
var srcURL = NSUrl.FromFilename ("FromFile.txt");
var srcIntent = NSFileAccessIntent.CreateReadingIntent (srcURL, NSFileCoordinatorReadingOptions.ForUploading);

// Get destination options
var dstURL = NSUrl.FromFilename ("ToFile.txt");
var dstIntent = NSFileAccessIntent.CreateReadingIntent (dstURL, NSFileCoordinatorReadingOptions.ForUploading);

// Create an array
var intents = new NSFileAccessIntent[] {
    srcIntent,
    dstIntent
};

// Initialize a file coordination with intents
var queue = new NSOperationQueue ();
var fileCoordinator = new NSFileCoordinator ();
fileCoordinator.CoordinateAccess (intents, queue, (err) => {
    // Was there an error?
    if (err!=null) {
        Console.WriteLine("Error: {0}",err.LocalizedDescription);
    }
});

Belgeleri bulma ve listeleme

Belgeleri bulma ve listeleme yöntemi, var olan NSMetadataQuery API 'leri kullanmaktır. Bu bölüm, NSMetadataQuery daha önce, belgelerle çalışmayı daha da kolay hale getirmeye eklenen yeni özellikleri kapsar.

Mevcut davranış

İOS 8 ' den önce, şu NSMetadataQuery gibi yerel dosya değişikliklerinin alımı yavaş oldu: siler, oluşturuyor ve yeniden adlandırılır.

Yukarıdaki diyagramda:

1. Uygulama kapsayıcısında zaten var olan dosyalar için, NSMetadataQueryNSMetadata önceden oluşturulmuş ve biriktirilir kayıtlar, uygulama tarafından anında kullanılabilir.
2. Uygulama, uygulama kapsayıcısında yeni bir dosya oluşturur.
3. Uygulama kapsayıcısında değişikliği görmeden önce bir gecikme var NSMetadataQuery ve gerekli NSMetadata kaydı oluşturuyor.

Kayıt oluşturma gecikmesi nedeniyle NSMetadata , uygulamanın iki veri kaynağı açık olmalıdır: biri yerel dosya değişiklikleri ve bulut tabanlı değişiklikler için bir tane.

Birleştirme

İOS 8 ' de, NSMetadataQuery doğrudan birleştirme adlı yeni bir özellik ile kullanımı daha kolaydır:

Yukarıdaki diyagramda dikiş kullanımı:

1. Daha önce olduğu gibi, uygulama kapsayıcısında zaten bulunan dosyalar için NSMetadataQueryNSMetadata önceden oluşturulmuş ve biriktirilen mevcut kayıtlar vardır.
2. Uygulama, dosya koordinasyonu kullanarak uygulama kapsayıcısında yeni bir dosya oluşturur.
3. Uygulama kapsayıcısında bir kanca, NSMetadataQuery gerekli kaydı oluşturmak için değişikliği ve çağrıları görür NSMetadata .
4. NSMetadataKayıt, dosya sonrasında doğrudan oluşturulur ve uygulama için kullanılabilir hale getirilir.

İzleme kullanarak, uygulamanın yerel ve bulut tabanlı dosya değişikliklerini izlemek için bir veri kaynağını açması artık gerekmez. Artık uygulama doğrudan bağlı olabilir NSMetadataQuery .

Yeni iOS 8 meta veri özellikleri

İOS 8 ' de aşağıdaki yeni özellikler eklenmiştir NSMetadataQuery :

• NSMetatadataQuery , artık bulutta depolanan yerel olmayan belgeleri listeleyebilir.
• Bulut tabanlı belgelerde meta veri bilgilerine erişmek için yeni API 'Ler eklenmiştir.
• NSUrl_PromisedItemsİçeriğinin yerel olarak kullanılabilir olması veya bulunmayabilir dosya özniteliklerine erişecek yeni bir API vardır.
• Belirli bir GetPromisedItemResourceValue dosya hakkında bilgi almak için yöntemini kullanın veya GetPromisedItemResourceValues aynı anda birden fazla dosya hakkında bilgi almak için yöntemini kullanın.

Meta verilerle ilgili olarak iki yeni dosya düzenleme bayrağı eklenmiştir:

• NSFileCoordinatorReadImmediatelyAvailableMetadataOnly
• NSFileCoordinatorWriteContentIndependentMetadataOnly

Yukarıdaki bayraklar sayesinde belge dosyasının içeriğinin kullanılabilmesi için yerel olarak kullanılabilir olması gerekmez.

Aşağıdaki kod segmenti, NSMetadataQuery belirli bir dosyanın varolup olmadığını sorgulamak ve yoksa dosyayı oluşturmak için nasıl kullanılacağını gösterir:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Foundation;
using UIKit;
using ObjCRuntime;
using System.IO;

#region Static Properties
public const string TestFilename = "test.txt";
#endregion

#region Computed Properties
public bool HasiCloud { get; set; }
public bool CheckingForiCloud { get; set; }
public NSUrl iCloudUrl { get; set; }

public GenericTextDocument Document { get; set; }
public NSMetadataQuery Query { get; set; }
#endregion

#region Private Methods
private void FindDocument () {
    Console.WriteLine ("Finding Document...");

    // Create a new query and set it's scope
    Query = new NSMetadataQuery();
    Query.SearchScopes = new NSObject [] {
                NSMetadataQuery.UbiquitousDocumentsScope,
                NSMetadataQuery.UbiquitousDataScope,
                NSMetadataQuery.AccessibleUbiquitousExternalDocumentsScope
            };

    // Build a predicate to locate the file by name and attach it to the query
    var pred = NSPredicate.FromFormat ("%K == %@"
        , new NSObject[] {
            NSMetadataQuery.ItemFSNameKey
            , new NSString(TestFilename)});
    Query.Predicate = pred;

    // Register a notification for when the query returns
    NSNotificationCenter.DefaultCenter.AddObserver (this,
            new Selector("queryDidFinishGathering:"),             NSMetadataQuery.DidFinishGatheringNotification,
            Query);

    // Start looking for the file
    Query.StartQuery ();
    Console.WriteLine ("Querying: {0}", Query.IsGathering);
}

[Export("queryDidFinishGathering:")]
public void DidFinishGathering (NSNotification notification) {
    Console.WriteLine ("Finish Gathering Documents.");

    // Access the query and stop it from running
    var query = (NSMetadataQuery)notification.Object;
    query.DisableUpdates();
    query.StopQuery();

    // Release the notification
    NSNotificationCenter.DefaultCenter.RemoveObserver (this
        , NSMetadataQuery.DidFinishGatheringNotification
        , query);

    // Load the document that the query returned
    LoadDocument(query);
}

private void LoadDocument (NSMetadataQuery query) {
    Console.WriteLine ("Loading Document...");    

    // Take action based on the returned record count
    switch (query.ResultCount) {
    case 0:
        // Create a new document
        CreateNewDocument ();
        break;
    case 1:
        // Gain access to the url and create a new document from
        // that instance
        NSMetadataItem item = (NSMetadataItem)query.ResultAtIndex (0);
        var url = (NSUrl)item.ValueForAttribute (NSMetadataQuery.ItemURLKey);

        // Load the document
        OpenDocument (url);
        break;
    default:
        // There has been an issue
        Console.WriteLine ("Issue: More than one document found...");
        break;
    }
}
#endregion

#region Public Methods
public void OpenDocument(NSUrl url) {

    Console.WriteLine ("Attempting to open: {0}", url);
    Document = new GenericTextDocument (url);

    // Open the document
    Document.Open ( (success) => {
        if (success) {
            Console.WriteLine ("Document Opened");
        } else
            Console.WriteLine ("Failed to Open Document");
    });

    // Inform caller
    RaiseDocumentLoaded (Document);
}

public void CreateNewDocument() {
    // Create path to new file
    // var docsFolder = Environment.GetFolderPath (Environment.SpecialFolder.Personal);
    var docsFolder = Path.Combine(iCloudUrl.Path, "Documents");
    var docPath = Path.Combine (docsFolder, TestFilename);
    var ubiq = new NSUrl (docPath, false);

    // Create new document at path
    Console.WriteLine ("Creating Document at:" + ubiq.AbsoluteString);
    Document = new GenericTextDocument (ubiq);

    // Set the default value
    Document.Contents = "(default value)";

    // Save document to path
    Document.Save (Document.FileUrl, UIDocumentSaveOperation.ForCreating, (saveSuccess) => {
        Console.WriteLine ("Save completion:" + saveSuccess);
        if (saveSuccess) {
            Console.WriteLine ("Document Saved");
        } else {
            Console.WriteLine ("Unable to Save Document");
        }
    });

    // Inform caller
    RaiseDocumentLoaded (Document);
}

public bool SaveDocument() {
    bool successful = false;

    // Save document to path
    Document.Save (Document.FileUrl, UIDocumentSaveOperation.ForOverwriting, (saveSuccess) => {
        Console.WriteLine ("Save completion: " + saveSuccess);
        if (saveSuccess) {
            Console.WriteLine ("Document Saved");
            successful = true;
        } else {
            Console.WriteLine ("Unable to Save Document");
            successful=false;
        }
    });

    // Return results
    return successful;
}
#endregion

#region Events
public delegate void DocumentLoadedDelegate(GenericTextDocument document);
public event DocumentLoadedDelegate DocumentLoaded;

internal void RaiseDocumentLoaded(GenericTextDocument document) {
    // Inform caller
    if (this.DocumentLoaded != null) {
        this.DocumentLoaded (document);
    }
}
#endregion

Belge küçük resimleri

Apple, bir uygulama için belgelerin listelenmesi sırasında en iyi kullanıcı deneyiminin önizlemeleri Kullandır. Bu, son kullanıcılar bağlamını sağlar, bu sayede birlikte çalışmak istedikleri belgeyi hızlıca tanımlayabilirler.

İOS 8 ' den önce, belge önizlemelerinin gösterilmesi özel bir uygulama gerektirir. İOS 8 ' den yeni, geliştiricinin belge küçük resimleriyle hızla çalışmasına izin veren dosya sistemi öznitelikleridir.

Belge küçük resimleri alınıyor

GetPromisedItemResourceValueVeya GetPromisedItemResourceValues yöntemlerini çağırarak NSUrl_PromisedItems API, a NSUrlThumbnailDictionary döndürülür. Şu anda bu sözlükte yer aldığı tek anahtar, NSThumbnial1024X1024SizeKey ve eşleşmesinden bağımsız olur UIImage .

Belge küçük resimleri kaydediliyor

Küçük resim eklemenin en kolay yolu, ' ı kullanmaktır UIDocument . GetFileAttributesToWriteYöntemini çağırarak UIDocument ve küçük resmi ayarlayarak, belge dosyası olduğunda otomatik olarak kaydedilir. İCloud Daemon, bu değişikliği görebilir ve iCloud 'a yayacaktır. Mac OS X, küçük resimler geliştirici için hızlı bakış eklentisi tarafından otomatik olarak oluşturulur.

iCloud tabanlı Belgelerle çalışmayla ilgili temel bilgiler ve mevcut API'de yapılan değişikliklerle birlikte, belge seçici görünüm denetleyicisini bir Xamarin iOS 8 Mobil Uygulamasında uygulamaya hazırız.

Xamarin'de iCloud'u etkinleştirme

Belge Seçici'nin bir Xamarin.iOS Uygulamasında kullanılamadan önce, iCloud desteğinin hem uygulama hem de Apple aracılığıyla etkinleştirilmesi gerekir.

Aşağıdaki adımlarda iCloud için sağlama işlemi adım adım açıklanır.

1. iCloud Kapsayıcısı oluşturun.
2. iCloud hesabı içeren bir Uygulama Kimliği App Service.
3. Bu Uygulama Kimliğini içeren bir Sağlama profili oluşturun.

Özelliklerle Çalışma kılavuzu ilk iki adımda size yol sağlar. Sağlama profili oluşturmak için Sağlama Profili kılavuzunda yer alan adımları izleyin.

Aşağıdaki adımlarda, iCloud için uygulama yapılandırma işlemi adım adım izlenir:

Şunları yapın:

1. Projeyi Mac için Visual Studio veya Visual Studio.

2. Giriş Çözüm Gezgini,projeye sağ tıklayın ve Seçenekler'i seçin.

3. Seçenekler İletişim Kutusu'nda iOS Uygulaması'ı seçin,Paket Tanımlayıcısı'nın yukarıda uygulama için oluşturulan Uygulama Kimliği'nde tanımlanmış olanla eş olduğundan emin olur.

4. iOS Paket İmzalama'yatıklayın, Geliştirici Kimliği'ne ve yukarıda oluşturulan Sağlama Profili'ne tıklayın.

5. Değişiklikleri kaydetmek ve iletişim kutusunu kapatmak için Tamam düğmesine tıklayın.

6. Düzenleyicide sağ Entitlements.plist tık Entitlements.plist düzenleyicide açın.

   Önemli

   Bu Visual Studio sağ tıklayarak, Birlikte Aç... seçeneğini ve Özellik Listesi Düzenleyicisi'ni seçerek Yetkilendirmeler düzenleyicisini açmanız gerekir

7. iCloud, iCloud Belgeleri, Anahtar-değer depolama ve CloudKit'i etkinleştir'i seçin.

8. Kapsayıcının uygulama için mevcut olduğundan emin olun (yukarıda oluşturulan şekilde). Örnek: iCloud.com.your-company.AppName

9. Dosyadaki değişiklikleri kaydedin.

Yetkilendirmeler hakkında daha fazla bilgi için Yetkilendirmelerle Çalışma kılavuzuna bakın.

Yukarıdaki kurulumda uygulama artık bulut tabanlı belgeleri ve yeni Belge Seçici Görünüm Denetleyicisini kullanabilir.

Ortak Kurulum Kodu

Belge Seçici Görünüm Denetleyicisi'ne başlamadan önce bazı standart kurulum kodu gerekir. Uygulamanın dosyasını değiştirerek AppDelegate.cs başlangıç yapın ve aşağıdaki gibi bir görünüme kaydedin:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Foundation;
using UIKit;
using ObjCRuntime;
using System.IO;

namespace DocPicker
{

    [Register ("AppDelegate")]
    public partial class AppDelegate : UIApplicationDelegate
    {
        #region Static Properties
        public const string TestFilename = "test.txt";
        #endregion

        #region Computed Properties
        public override UIWindow Window { get; set; }
        public bool HasiCloud { get; set; }
        public bool CheckingForiCloud { get; set; }
        public NSUrl iCloudUrl { get; set; }

        public GenericTextDocument Document { get; set; }
        public NSMetadataQuery Query { get; set; }
        public NSData Bookmark { get; set; }
        #endregion

        #region Private Methods
        private void FindDocument () {
            Console.WriteLine ("Finding Document...");

            // Create a new query and set it's scope
            Query = new NSMetadataQuery();
            Query.SearchScopes = new NSObject [] {
                NSMetadataQuery.UbiquitousDocumentsScope,
                NSMetadataQuery.UbiquitousDataScope,
                NSMetadataQuery.AccessibleUbiquitousExternalDocumentsScope
            };

            // Build a predicate to locate the file by name and attach it to the query
            var pred = NSPredicate.FromFormat ("%K == %@",
                 new NSObject[] {NSMetadataQuery.ItemFSNameKey
                , new NSString(TestFilename)});
            Query.Predicate = pred;

            // Register a notification for when the query returns
            NSNotificationCenter.DefaultCenter.AddObserver (this
                , new Selector("queryDidFinishGathering:")
                , NSMetadataQuery.DidFinishGatheringNotification
                , Query);

            // Start looking for the file
            Query.StartQuery ();
            Console.WriteLine ("Querying: {0}", Query.IsGathering);
        }

        [Export("queryDidFinishGathering:")]
        public void DidFinishGathering (NSNotification notification) {
            Console.WriteLine ("Finish Gathering Documents.");

            // Access the query and stop it from running
            var query = (NSMetadataQuery)notification.Object;
            query.DisableUpdates();
            query.StopQuery();

            // Release the notification
            NSNotificationCenter.DefaultCenter.RemoveObserver (this
                , NSMetadataQuery.DidFinishGatheringNotification
                , query);

            // Load the document that the query returned
            LoadDocument(query);
        }

        private void LoadDocument (NSMetadataQuery query) {
            Console.WriteLine ("Loading Document...");    

            // Take action based on the returned record count
            switch (query.ResultCount) {
            case 0:
                // Create a new document
                CreateNewDocument ();
                break;
            case 1:
                // Gain access to the url and create a new document from
                // that instance
                NSMetadataItem item = (NSMetadataItem)query.ResultAtIndex (0);
                var url = (NSUrl)item.ValueForAttribute (NSMetadataQuery.ItemURLKey);

                // Load the document
                OpenDocument (url);
                break;
            default:
                // There has been an issue
                Console.WriteLine ("Issue: More than one document found...");
                break;
            }
        }
        #endregion

        #region Public Methods

        public void OpenDocument(NSUrl url) {

            Console.WriteLine ("Attempting to open: {0}", url);
            Document = new GenericTextDocument (url);

            // Open the document
            Document.Open ( (success) => {
                if (success) {
                    Console.WriteLine ("Document Opened");
                } else
                    Console.WriteLine ("Failed to Open Document");
            });

            // Inform caller
            RaiseDocumentLoaded (Document);
        }

        public void CreateNewDocument() {
            // Create path to new file
            // var docsFolder = Environment.GetFolderPath (Environment.SpecialFolder.Personal);
            var docsFolder = Path.Combine(iCloudUrl.Path, "Documents");
            var docPath = Path.Combine (docsFolder, TestFilename);
            var ubiq = new NSUrl (docPath, false);

            // Create new document at path
            Console.WriteLine ("Creating Document at:" + ubiq.AbsoluteString);
            Document = new GenericTextDocument (ubiq);

            // Set the default value
            Document.Contents = "(default value)";

            // Save document to path
            Document.Save (Document.FileUrl, UIDocumentSaveOperation.ForCreating, (saveSuccess) => {
                Console.WriteLine ("Save completion:" + saveSuccess);
                if (saveSuccess) {
                    Console.WriteLine ("Document Saved");
                } else {
                    Console.WriteLine ("Unable to Save Document");
                }
            });

            // Inform caller
            RaiseDocumentLoaded (Document);
        }

        /// <summary>
        /// Saves the document.
        /// </summary>
        /// <returns><c>true</c>, if document was saved, <c>false</c> otherwise.</returns>
        public bool SaveDocument() {
            bool successful = false;

            // Save document to path
            Document.Save (Document.FileUrl, UIDocumentSaveOperation.ForOverwriting, (saveSuccess) => {
                Console.WriteLine ("Save completion: " + saveSuccess);
                if (saveSuccess) {
                    Console.WriteLine ("Document Saved");
                    successful = true;
                } else {
                    Console.WriteLine ("Unable to Save Document");
                    successful=false;
                }
            });

            // Return results
            return successful;
        }
        #endregion

        #region Override Methods
        public override void FinishedLaunching (UIApplication application)
        {

            // Start a new thread to check and see if the user has iCloud
            // enabled.
            new Thread(new ThreadStart(() => {
                // Inform caller that we are checking for iCloud
                CheckingForiCloud = true;

                // Checks to see if the user of this device has iCloud
                // enabled
                var uburl = NSFileManager.DefaultManager.GetUrlForUbiquityContainer(null);

                // Connected to iCloud?
                if (uburl == null)
                {
                    // No, inform caller
                    HasiCloud = false;
                    iCloudUrl =null;
                    Console.WriteLine("Unable to connect to iCloud");
                    InvokeOnMainThread(()=>{
                        var okAlertController = UIAlertController.Create ("iCloud Not Available", "Developer, please check your Entitlements.plist, Bundle ID and Provisioning Profiles.", UIAlertControllerStyle.Alert);
                        okAlertController.AddAction (UIAlertAction.Create ("Ok", UIAlertActionStyle.Default, null));
                        Window.RootViewController.PresentViewController (okAlertController, true, null);
                    });
                }
                else
                {    
                    // Yes, inform caller and save location the Application Container
                    HasiCloud = true;
                    iCloudUrl = uburl;
                    Console.WriteLine("Connected to iCloud");

                    // If we have made the connection with iCloud, start looking for documents
                    InvokeOnMainThread(()=>{
                        // Search for the default document
                        FindDocument ();
                    });
                }

                // Inform caller that we are no longer looking for iCloud
                CheckingForiCloud = false;

            })).Start();

        }

        // This method is invoked when the application is about to move from active to inactive state.
        // OpenGL applications should use this method to pause.
        public override void OnResignActivation (UIApplication application)
        {
        }

        // This method should be used to release shared resources and it should store the application state.
        // If your application supports background execution this method is called instead of WillTerminate
        // when the user quits.
        public override void DidEnterBackground (UIApplication application)
        {
            // Trap all errors
            try {
                // Values to include in the bookmark packet
                var resources = new string[] {
                    NSUrl.FileSecurityKey,
                    NSUrl.ContentModificationDateKey,
                    NSUrl.FileResourceIdentifierKey,
                    NSUrl.FileResourceTypeKey,
                    NSUrl.LocalizedNameKey
                };

                // Create the bookmark
                NSError err;
                Bookmark = Document.FileUrl.CreateBookmarkData (NSUrlBookmarkCreationOptions.WithSecurityScope, resources, iCloudUrl, out err);

                // Was there an error?
                if (err != null) {
                    // Yes, report it
                    Console.WriteLine ("Error Creating Bookmark: {0}", err.LocalizedDescription);
                }
            }
            catch (Exception e) {
                // Report error
                Console.WriteLine ("Error: {0}", e.Message);
            }
        }

        // This method is called as part of the transition from background to active state.
        public override void WillEnterForeground (UIApplication application)
        {
            // Is there any bookmark data?
            if (Bookmark != null) {
                // Trap all errors
                try {
                    // Yes, attempt to restore it
                    bool isBookmarkStale;
                    NSError err;
                    var srcUrl = new NSUrl (Bookmark, NSUrlBookmarkResolutionOptions.WithSecurityScope, iCloudUrl, out isBookmarkStale, out err);

                    // Was there an error?
                    if (err != null) {
                        // Yes, report it
                        Console.WriteLine ("Error Loading Bookmark: {0}", err.LocalizedDescription);
                    } else {
                        // Load document from bookmark
                        OpenDocument (srcUrl);
                    }
                }
                catch (Exception e) {
                    // Report error
                    Console.WriteLine ("Error: {0}", e.Message);
                }
            }

        }

        // This method is called when the application is about to terminate. Save data, if needed.
        public override void WillTerminate (UIApplication application)
        {
        }
        #endregion

        #region Events
        public delegate void DocumentLoadedDelegate(GenericTextDocument document);
        public event DocumentLoadedDelegate DocumentLoaded;

        internal void RaiseDocumentLoaded(GenericTextDocument document) {
            // Inform caller
            if (this.DocumentLoaded != null) {
                this.DocumentLoaded (document);
            }
        }
        #endregion
    }
}

Yukarıdaki kod, uygulamanın geri kalanında birlikte çalışmalarını kolaylaştırmak için çeşitli iCloud Sürücü kısayollarını ortaya çıkarır.

Ardından, Belge Seçici'yi kullanmak veya bulut tabanlı belgelerle çalışmak için aşağıdaki kodu herhangi bir görünüme veya görünüm kapsayıcıya ekleyin:

using CloudKit;
...

#region Computed Properties
/// <summary>
/// Returns the delegate of the current running application
/// </summary>
/// <value>The this app.</value>
public AppDelegate ThisApp {
    get { return (AppDelegate)UIApplication.SharedApplication.Delegate; }
}
#endregion

Bu, öğesini almak ve yukarıda oluşturulan AppDelegate iCloud kısayollarına erişmek için bir kısayol ekler.

Bu kod geçerli olduğu için bir Xamarin iOS 8 uygulamasında Belge Seçici Görünüm Denetleyicisi'nin uygulanmasına göz atabilirsiniz.

Belge Seçici Görünüm Denetleyicisini Kullanma

iOS 8'den önce, uygulamanın dışındaki belgeleri uygulamanın içinde bulmanın bir yolu yoktu çünkü belgelere başka bir uygulamanın erişmesi çok zordu.

Mevcut Davranış

iOS 8'den önceki bir dış belgeye erişime göz atabilirsiniz:

1. İlk olarak kullanıcının belgeyi oluşturan uygulamayı açması gerekir.
2. Belge seçilidir ve UIDocumentInteractionController belgeyi yeni uygulamaya göndermek için kullanılır.
3. Son olarak, özgün Belgenin bir kopyası yeni uygulamanın Kapsayıcısı'nın içine yerleştirilir.

Buradan, ikinci uygulamanın açması ve düzenlemesi için Belge kullanılabilir.

Bir Uygulamanın Kapsayıcısı Dışındaki Belgeleri Bulma

iOS 8'de, bir uygulama kendi Uygulama Kapsayıcısı dışındaki Belgelere kolaylıkla erişebilir:

Yeni iCloud Belge Seçicisini ( ) kullanarak bir iOS uygulaması, Uygulama Kapsayıcısı'nın dışında UIDocumentPickerViewController doğrudan keşfedebilir ve bu uygulamaya erişebilir. , UIDocumentPickerViewController kullanıcıya erişim izni vermek ve bulunan belgeleri izinler aracılığıyla düzenlemek için bir mekanizma sağlar.

Bir uygulama, Belgelerinin iCloud Belge Seçicisi'ne dahil olması ve diğer uygulamaların bunları keşfetmesi ve onunla çalışması için kullanılabilir olması gerekir. Xamarin iOS 8 uygulamasının Uygulama Kapsayıcısını paylaşmasını sağlanacak şekilde, dosyayı standart bir metin düzenleyicisinde düzenleyin ve aşağıdaki iki satırı sözlüğün en altına Info.plist ekleyin (etiketler <dict>...</dict> arasında):

<key>NSUbiquitousContainerIsDocumentScopePublic</key>
<true/>

, UIDocumentPickerViewController kullanıcının belgeleri seçmesi için harika bir yeni kullanıcı arabirimi sağlar. Belge Seçici Görünüm Denetleyicisini bir Xamarin iOS 8 uygulamasında görüntülemek için şunları yapın:

using MobileCoreServices;
...

// Allow the Document picker to select a range of document types
        var allowedUTIs = new string[] {
            UTType.UTF8PlainText,
            UTType.PlainText,
            UTType.RTF,
            UTType.PNG,
            UTType.Text,
            UTType.PDF,
            UTType.Image
        };

        // Display the picker
        //var picker = new UIDocumentPickerViewController (allowedUTIs, UIDocumentPickerMode.Open);
        var pickerMenu = new UIDocumentMenuViewController(allowedUTIs, UIDocumentPickerMode.Open);
        pickerMenu.DidPickDocumentPicker += (sender, args) => {

            // Wireup Document Picker
            args.DocumentPicker.DidPickDocument += (sndr, pArgs) => {

                // IMPORTANT! You must lock the security scope before you can
                // access this file
                var securityEnabled = pArgs.Url.StartAccessingSecurityScopedResource();

                // Open the document
                ThisApp.OpenDocument(pArgs.Url);

                // IMPORTANT! You must release the security lock established
                // above.
                pArgs.Url.StopAccessingSecurityScopedResource();
            };

            // Display the document picker
            PresentViewController(args.DocumentPicker,true,null);
        };

pickerMenu.ModalPresentationStyle = UIModalPresentationStyle.Popover;
PresentViewController(pickerMenu,true,null);
UIPopoverPresentationController presentationPopover = pickerMenu.PopoverPresentationController;
if (presentationPopover!=null) {
    presentationPopover.SourceView = this.View;
    presentationPopover.PermittedArrowDirections = UIPopoverArrowDirection.Down;
    presentationPopover.SourceRect = ((UIButton)s).Frame;
}

Örnek Çıktı

Yukarıdaki kodun, bir iPhone cihazında çalıştırıcıda belge seçiciyi nasıl görüntüley iPhone ve bir örnek:

1. Kullanıcı uygulamayı başlatır ve ana arabirim görüntülenir:

   

2. Kullanıcı ekranın üst kısmında yer alan Eylem Düğmesine dokunarak kullanılabilir sağlayıcılar listesinden bir Belge Sağlayıcısı seçmesi istenmektedir:

   

3. Seçilen Belge Sağlayıcısı için Belge Seçici Görünüm Denetleyicisi görüntülenir:

   

4. Kullanıcı bir Belge Klasörüne dokunarak içeriğini görüntüler:

   

5. Kullanıcı bir Belge seçer ve Belge Seçici kapatılır.

6. Ana arabirim yeniden oynatıldı, Belge dış Kapsayıcıdan yüklenir ve içeriği görüntülenir.

Belge Seçici Görünüm Denetleyicisi'nin gerçek görüntüsü, kullanıcının cihaza yüklemiş olduğu Belge Sağlayıcılarına ve hangi Belge Seçici Modunun uygulanmış olduğuna bağlıdır. Yukarıdaki örnek Açık Modu kullanmaktır, diğer mod türleri aşağıda ayrıntılı olarak ele alınmaktadır.

Dış Belgeleri Yönetme

Yukarıda da belirtildiği gibi, iOS 8'den önce bir uygulama yalnızca Uygulama Kapsayıcısı'nın parçası olan belgelere erişebilirdi. iOS 8'de bir uygulama dış kaynaklardan Belgeler'e erişebilir:

Kullanıcı dış kaynaktan bir Belgeyi seçerse, Uygulama Kapsayıcısı'ne özgün Belgeyi ifade etmek için bir Başvuru Belgesi yazılır.

Bu yeni özelliği mevcut uygulamalara eklemeye yardımcı olmak için API'ye birkaç yeni özellik NSMetadataQuery eklenmiştir. Genellikle bir uygulama, Uygulama Kapsayıcısı içinde bulunan belgeleri listelemektedir. Bu kapsam kullanılarak, yalnızca Uygulama Kapsayıcısı içindeki belgeler görüntülenmeye devam eder.

Yeni Ubiquitous Dış Belge Kapsamı'nın kullanımı, Uygulama Kapsayıcısı'nın dışında yer alan Belgeleri ve onlar için meta verileri geri döner. NSMetadataItemUrlKey, Belgenin gerçekten bulunduğu URL'ye işarettir.

Bazen bir uygulama, başvuruyla işaret eden Belgelerle çalışmak istemez. Bunun yerine, uygulama doğrudan Başvuru Belgesi ile çalışmak ister. Örneğin, uygulama belgeyi kullanıcı arabiriminde Uygulamanın klasöründe görüntülemek veya kullanıcının başvuruları bir klasörün içine taşımasına izin vermek istiyor olabilir.

iOS 8'de, Başvuru NSMetadataItemUrlInLocalContainerKey Belgesi'ne doğrudan erişmek için yeni bir sağlanmıştır. Bu anahtar, bir Uygulama Kapsayıcısı'nın dış belgesinde gerçek başvuruya gösterir.

, NSMetadataUbiquitousItemIsExternalDocumentKey bir belgenin Bir Uygulamanın Kapsayıcısı'nın dışında olup olmadığını test etmek için kullanılır. NSMetadataUbiquitousItemContainerDisplayNameKey, dış belgenin özgün kopyasının yer alan Kapsayıcı adına erişmek için kullanılır.

Belge Başvuruları Neden Gereklidir?

iOS 8'in dış Belgelere erişmek için başvurular kullanmanın ana nedeni güvenliktir. Hiçbir uygulamaya başka bir uygulamanın Kapsayıcısı için erişim izni verilmemektedir. İşlem tükendi ve sistem genelinde erişime sahip olduğundan bunu yalnızca Belge Seçici yapar.

Uygulama Kapsayıcısı dışında bir belgeye varmanın tek yolu Belge Seçici'yi kullanmak ve seçici tarafından döndürülen URL'nin Güvenlik Kapsamı'dır. Güvenlik Kapsamlı URL'si, belgeyi seçecek yeterli bilgiyi ve belgeye uygulama erişimi vermek için gereken kapsamlı hakları içerir.

Güvenlik Kapsamı Kapsamı Alınmış URL'nin bir dizede seri hale getirilse ve sonra seri durumdan kaldırılsa, Güvenlik Bilgileri'nin kaybedilir ve url'den dosyaya erişilemeyecek olması önemlidir. Belge Başvurusu özelliği, bu URL'ler tarafından işaret eden dosyalara geri dönmek için bir mekanizma sağlar.

Bu nedenle, uygulama Başvuru Belgelerinden birini aldısa, zaten güvenlik kapsamı eklenmiştir ve NSUrl dosyaya erişmek için kullanılabilir. Bu nedenle, geliştiricinin tüm bu bilgileri ve işlemleri onlar için işlemesi nedeniyle UIDocument kullanması kesinlikle önerilir.

Yer İşaretlerini Kullanma

Örneğin durum geri yüklemesi yaparken belirli bir Belgeye geri dönmek için bir uygulamanın Belgeleri'nin numaralarını almak her zaman uygun değildir. iOS 8, belirli bir Belgeyi doğrudan hedef alan Yer İşaretleri oluşturmak için bir mekanizma sağlar.

Aşağıdaki kod, bir 'nin özelliğinden Bir UIDocument Yer İşareti FileUrl oluşturacak:

// Trap all errors
try {
    // Values to include in the bookmark packet
    var resources = new string[] {
        NSUrl.FileSecurityKey,
        NSUrl.ContentModificationDateKey,
        NSUrl.FileResourceIdentifierKey,
        NSUrl.FileResourceTypeKey,
        NSUrl.LocalizedNameKey
    };

    // Create the bookmark
    NSError err;
    Bookmark = Document.FileUrl.CreateBookmarkData (NSUrlBookmarkCreationOptions.WithSecurityScope, resources, iCloudUrl, out err);

    // Was there an error?
    if (err != null) {
        // Yes, report it
        Console.WriteLine ("Error Creating Bookmark: {0}", err.LocalizedDescription);
    }
}
catch (Exception e) {
    // Report error
    Console.WriteLine ("Error: {0}", e.Message);
}

Var olan Yer İşareti API'si, bir dış dosyaya doğrudan erişim sağlamak için kaydedilebilir ve yüklenebilir mevcut bir Yer İşareti NSUrl oluşturmak için kullanılır. Aşağıdaki kod, yukarıda oluşturulmuş bir yer işaretini geri yüklemektedir:

if (Bookmark != null) {
    // Trap all errors
    try {
        // Yes, attempt to restore it
        bool isBookmarkStale;
        NSError err;
        var srcUrl = new NSUrl (Bookmark, NSUrlBookmarkResolutionOptions.WithSecurityScope, iCloudUrl, out isBookmarkStale, out err);

        // Was there an error?
        if (err != null) {
            // Yes, report it
            Console.WriteLine ("Error Loading Bookmark: {0}", err.LocalizedDescription);
        } else {
            // Load document from bookmark
            OpenDocument (srcUrl);
        }
    }
    catch (Exception e) {
        // Report error
        Console.WriteLine ("Error: {0}", e.Message);
    }
}

Açma ve İçeri Aktarma Modu ile Belge Seçici karşılaştırması

Belge Seçici Görünüm Denetleyicisi iki farklı işlem modu sunar:

1. Açık Mod– Bu modda, kullanıcı ve dış Belge'yi seçerken, Belge Seçici Uygulama Kapsayıcısı'da Bir Güvenlik Kapsamlı Yer İşareti oluşturacak.

   

2. İçeri Aktarma Modu: Bu modda, kullanıcı ve dış Belgeyi seçerken Belge Seçici bir Yer İşareti oluşturmaz, bunun yerine dosyayı Geçici Bir Konuma kopyalayın ve bu konumdaki Belgeye uygulama erişimi sağlar:

   
   Uygulama herhangi bir nedenle sonlandırıldığı zaman Geçici Konum boşaltılır ve dosya kaldırılır. Uygulamanın dosyaya erişimi sürdürmesi gerekirse, bir kopyalayıp Uygulama Kapsayıcısı'nın üzerine yer açtırır.

Açık Mod, uygulama başka bir uygulamayla işbirliği yapmak ve belgede yapılan değişiklikleri bu uygulamayla paylaşmak istediği zaman kullanışlıdır. İçeri Aktarma Modu, uygulamanın belgede yaptığı değişiklikleri diğer uygulamalarla paylaşmak istemeyebilirsiniz.

BelgeYi Harici Yapma

Yukarıda belirtildiği gibi, bir iOS 8 uygulamasının kendi Uygulama Kapsayıcısı dışındaki kapsayıcılara erişimi yok. Uygulama yerel olarak veya Geçici Bir Konuma yazabilir, ardından özel bir belge modu kullanarak sonuçta elde edilen Belgeyi Uygulama Kapsayıcısı'nın dışında kullanıcı tarafından seçilen bir konuma taşımanızı sağlar.

Belgeyi dış konuma taşımak için şunları yapın:

1. İlk olarak yerel veya geçici bir konumda yeni bir Belge oluşturun.
2. Yeni NSUrl Belge'ye göre bir oluşturun.
3. Yeni bir Belge Seçici Görünüm Denetleyicisi açın ve Modu NSUrl ile bunu MoveToService iletir.
4. Kullanıcı yeni bir konum seçtiktan sonra Belge geçerli konumdan yeni konuma taşınır.
5. Dosyanın oluşturma uygulaması tarafından erişilebilir olması için uygulamanın Uygulama Kapsayıcısı'ne bir Başvuru Belgesi yazılır.

Bir Belgeyi dış konuma taşımak için aşağıdaki kod kullanılabilir: var picker = new UIDocumentPickerViewController (srcURL, UIDocumentPickerMode.MoveToService);

Yukarıdaki işlem tarafından döndürülen Başvuru Belgesi, Belge Seçici'nin Açık Modu tarafından oluşturulan belgeyle tamamen aynıdır. Ancak, uygulamanın bir Belgeyi başvuru tutmadan taşımak istediğiniz zamanlar olabilir.

Bir Belgeyi başvuru oluşturmadan taşımak için Modu ExportToService kullanın. Örnek: var picker = new UIDocumentPickerViewController (srcURL, UIDocumentPickerMode.ExportToService);

Modu ExportToService kullanırken, Belge dış Kapsayıcıya kopyalanır ve mevcut kopya özgün konumda bıraktır.

Belge Sağlayıcısı Uzantıları

iOS 8 ile Apple, son kullanıcının gerçekten nerede olursa olsun bulut tabanlı belgelerine erişmesini istiyor. Bu hedefe ulaşmak için iOS 8 yeni bir Belge Sağlayıcısı Uzantısı mekanizması sağlar.

Belge Sağlayıcısı Uzantısı nedir?

Basitçe ifade etmek gerekirse, Belge Sağlayıcısı Uzantısı bir geliştirici veya üçüncü taraf için mevcut iCloud depolama konumuyla tam olarak aynı şekilde erişilebilen bir uygulamaya alternatif belge depolama alanı sağlamanın bir yolutur.

Kullanıcı, Belge Seçici'den bu alternatif depolama konumlarından birini seçebilirsiniz ve bu konumdaki dosyalarla çalışmak için tam olarak aynı erişim modlarını (Aç, İçeri Aktar, Taşı veya Dışarı Aktar) kullanabilir.

Bu, iki farklı uzantı kullanılarak uygulanır:

• Belge Seçici Uzantısı – Kullanıcının alternatif bir depolama konumdan belge seçmesi için grafik arabirim sağlayan bir alt sınıf sağlar. Bu alt sınıf, Belge Seçici Görünüm Denetleyicisi'nin bir parçası olarak görüntülenir.
• Dosya Uzantısı Sağlama – Bu, aslında dosya içeriklerini sağlamayla ilgili kullanıcı arabirimi olmayan bir uzantıdır. Bu uzantılar Dosya Koordinasyonu ( ) aracılığıyla NSFileCoordinator sağlanır. Bu, Dosya Koordinasyonu'nın gerekli olduğu bir diğer önemli durumdur.

Aşağıdaki diyagramda Belge Sağlayıcısı Uzantıları ile çalışırken tipik veri akışı gösterilebilir:

Aşağıdaki işlem gerçekleşir:

1. Uygulama, kullanıcının çalışmak için bir dosya seçmesine olanak sağlayan bir Belge Seçici Denetleyicisi sunar.
2. Kullanıcı alternatif bir dosya konumu seçer ve kullanıcı UIViewController arabirimini görüntülemek için özel uzantı çağrılır.
3. Kullanıcı bu konumdan bir dosya seçer ve URL Belge Seçici'ye geri geçiri.
4. Belge Seçici dosyanın URL'sini seçer ve kullanıcının üzerinde çalışması için uygulamaya döndürür.
5. URL, dosya içeriğini uygulamaya geri dönmek için Dosya Düzenleyicisi'ne geçirildi.
6. Dosya Düzenleyicisi, dosyayı almak için özel Dosya Sağlayıcısı Uzantısını arar.
7. Dosyanın içeriği Dosya Düzenleyicisi'ne döndürülür.
8. Dosyanın içeriği uygulamaya döndürülür.

Güvenlik ve Yer İşaretleri

Bu bölüm, Yer İşaretleri aracılığıyla güvenliğin ve kalıcı dosya erişiminin Belge Sağlayıcısı Uzantıları ile nasıl çalıştığını hızlı bir şekilde inceler. Güvenlik ve Yer İşaretlerini uygulama kapsayıcılarına otomatik olarak kaydeden iCloud Belge Sağlayıcısı'nın aksine, Belge Sağlayıcısı Uzantıları Belge Başvuru Sistemi'nin bir parçası değildir.

Örneğin: kendi şirket Enterprise güvenli veri deposu sağlayan bir veri deposu ayarında yöneticiler, genel iCloud Sunucuları tarafından erişilen veya işlenen gizli şirket bilgilerini istemez. Bu nedenle, yerleşik Belge Başvuru Sistemi kullanılamaz.

Yer İşareti sistemi hala kullanılabilir ve yer işareti eklemeli bir URL'yi doğru bir şekilde işlemenin ve bu URL'nin işaret ettiği Belgenin içeriğinin geri dönmesi Dosya Sağlayıcısı Uzantısı'nın sorumluluğundadır.

Güvenlik amacıyla, iOS 8'in hangi uygulamanın hangi dosya sağlayıcısı içinde hangi tanımlayıcıya erişimi olduğuyla ilgili bilgileri kalıcı olarak bulunduran bir Yalıtım Katmanı vardır. Tüm dosya erişiminin bu Yalıtım Katmanı tarafından denetlendi.

Aşağıdaki diyagramda Yer İşaretleri ve Belge Sağlayıcısı Uzantısı ile çalışırken veri akışı gösterilebilir:

Aşağıdaki işlem gerçekleşir:

1. Uygulama arka planı girmek için ve durumunun kalıcı olması gerekiyor. Alternatif NSUrl depolamadaki bir dosyaya yer işareti oluşturmak için çağrısında bulunuyor.
2. NSUrl Belgeye kalıcı bir URL almak için Dosya Sağlayıcısı Uzantısı'nın çağrılması.
3. Dosya Sağlayıcısı Uzantısı URL'yi dizesi olarak NSUrl döndürür.
4. , NSUrl URL'yi bir Yer İşareti içinde paketler ve uygulamaya döndürür.
5. Uygulama arka planda olmaktan uyanıyor ve durumu geri yüklemesi gerekiyorsa Yer İşareti'ne NSUrl geçer.
6. NSUrl dosyanın URL'sini ile Dosya Sağlayıcısı Uzantısını arar.
7. Dosya Uzantısı Sağlayıcısı dosyaya erişer ve dosyanın konumunu olarak NSUrl döndürür.
8. Dosya konumu güvenlik bilgileriyle birlikte pakettedir ve uygulamaya geri döndürülür.

Buradan, uygulama dosyaya erişebilir ve normal şekilde bu dosyayla çalışabilirsiniz.

Dosya Yazma

Bu bölümde, Belge Sağlayıcısı Uzantısı ile dosyaları alternatif bir konuma yazmanın nasıl çalıştığını hızlı bir şekilde göz atabilirsiniz. iOS uygulaması, Bilgileri Uygulama Kapsayıcısı içindeki diske kaydetmek için Dosya Koordinasyonu kullanır. Dosya başarıyla yazıldığına kısa bir süre sonra, Dosya Sağlayıcısı Uzantısı bu değişiklik hakkında bilgi aecektir.

Bu noktada, Dosya Sağlayıcısı Uzantısı dosyayı alternatif konuma yüklemeye başlayabilir (veya dosyayı kirli ve karşıya yükleme gerektiren olarak işaretlenir).

Yeni Belge Sağlayıcısı Uzantıları Oluşturma

Yeni Belge Sağlayıcısı Uzantıları oluşturma, bu giriş makalesi kapsamının dışındadır. Bu bilgiler burada, bir kullanıcının iOS cihazına yüklemiş olduğu uzantılara bağlı olarak, bir uygulamanın Apple tarafından sağlanan iCloud konumunun dışındaki Belge depolama konumlarına erişimi olduğunu göstermek için sağlanır.

Geliştirici, Belge Seçiciyi kullanırken ve dış Belgelerle çalışırken bu gerçeğin farkında olmalı. Bu Belgenin iCloud'da barındırıldıklarını varsaymamalarını gerekir.

Depolama Sağlayıcısı veya Belge Seçici Uzantısı oluşturma hakkında daha fazla bilgi için lütfen Uygulama Uzantılarına Giriş belgesine bakın.

iCloud Sürücüsüne Geç

iOS 8'de, kullanıcılar iOS 7'de (ve önceki sistemlerde) kullanılan mevcut iCloud Belgeleri Sistemini kullanmaya devam etmek veya mevcut Belgeleri yeni iCloud Sürücüsü mekanizmasına geçirmeyi seçebilir.

Bu Mac OS X Yosemite Apple geriye dönük uyumluluk sağlamaz, bu nedenle tüm belgelerin iCloud Sürücüsüne geçirilir veya cihazlar arasında güncelleştirilmez.

Bir kullanıcının hesabı iCloud Drive'a geçirildikten sonra, yalnızca iCloud Drive kullanan cihazlar değişiklikleri bu cihazlar arasında Belgeler'e yayabilecektir.

Özet

Bu makalede, iCloud Sürücüsü'ne ve yeni Belge Seçici Görünüm Denetleyicisi'ne destek olmak için gereken mevcut iCloud API'leri üzerinde yapılan değişiklikler ele alınmaktadır. Dosya Koordinasyonu ve bulut tabanlı belgelerle çalışırken bunun neden önemli olduğunu ele aldı. Bir Xamarin.iOS Uygulamasında bulut tabanlı belgeleri etkinleştirmek için gereken kurulumu ele aldı ve Belge Seçici Görünüm Denetleyicisini kullanarak bir uygulamanın Uygulama Kapsayıcısı dışındaki belgelerle çalışmaya giriş niteliğinde bir bakış verdi.

Ayrıca, bu makalede Belge Sağlayıcısı Uzantıları ve geliştiricinin bulut tabanlı belgeleri işleyecek uygulamalar yazarken bunları neden farkında olması gerektiği kısaca ele alınan bir makale yer almaktadır.

İlişkili Bağlantılar

• DocPicker (örnek)
• iOS 8’e Giriş
• Uygulama Uzantılarına Giriş