Xamarin.iOS'ta Belge Seçici

Belge Seçici, belgelerin uygulamalar arasında paylaşılmasına izin verir. Bu belgeler iCloud'da veya farklı bir uygulamanın 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 genelinde eşitlenmiş tutmanın zorluğu nedeniyle, belirli bir miktarda gerekli karmaşıklığı ortaya koyar.

Gereksinimler

Bu makalede sunulan adımları tamamlamak için aşağıdakiler gereklidir:

• Xcode 7 ve iOS 8 veya üzeri – Apple'ın Xcode 7 ve iOS 8 veya daha yeni API'lerinin geliştiricinin bilgisayarına yüklenmesi ve yapılandırılması gerekir.
• Visual Studio veya Mac için Visual Studio – Mac için Visual Studio'nin en son sürümü yüklenmelidir.
• iOS Cihazı – iOS 8 veya üzerini çalıştıran bir iOS cihazı.

iCloud'daki değişiklikler

Belge Seçici'nin yeni özelliklerini uygulamak için Apple'ın iCloud Hizmetinde aşağıdaki değişiklikler yapılmıştır:

• iCloud Daemon, CloudKit kullanılarak tamamen yeniden yazılmıştır.
• Mevcut iCloud özellikleri iCloud Drive olarak yeniden adlandırıldı.
• iCloud'a Microsoft Windows işletim sistemi desteği eklendi.
• Mac OS Bulucu'ya bir iCloud klasörü eklendi.
• iOS cihazları Mac OS iCloud klasörünün içeriğine erişebilir.

Önemli

Apple , geliştiricilerin Avrupa Birliği Genel Veri Koruma Yönetmeliği'ni (GDPR) düzgün bir şekilde işlemesine yardımcı olacak araçlar sağlar.

Belge nedir?

iCloud'da bir Belgeye başvururken, tek başına bir varlıktır ve kullanıcı tarafından bu şekilde algılanmalıdır. Kullanıcı belgeyi değiştirmek veya diğer kullanıcılarla paylaşmak isteyebilir (örneğin, e-posta kullanarak).

Kullanıcının hemen Belgeler olarak tanıyacağı Sayfalar, Keynote veya Numbers dosyaları gibi çeşitli dosya türleri vardır. Ancak, iCloud bu kavramla sınırlı değildir. Örneğin, bir oyunun durumu (satranç maçı gibi) bir belge olarak ele alınıp iCloud'da depolanabilir. Bu dosya bir kullanıcının cihazları arasında geçirilebilir ve başka bir cihazda kaldığı yerden bir oyun almasına izin verebilir.

Belgelerle ilgilenme

Belge Seçici'yi Xamarin ile kullanmak için gereken koda geçmeden önce, bu makale iCloud Belgeleriyle çalışmaya yönelik en iyi yöntemleri ve Belge Seçici'yi desteklemek için gereken mevcut API'lerde yapılan değişikliklerin birkaçını ele alacağız.

Dosya Koordinasyonu Kullanma

Bir dosya birkaç farklı konumdan değiştirilebildiği için, veri kaybını önlemek için koordinasyon kullanılmalıdır.

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

1. Dosya koordinasyonu kullanan bir iOS cihazı yeni bir Belge oluşturur ve bunu iCloud Klasörüne kaydeder.
2. iCloud, değiştirilen dosyayı her cihaza dağıtım için buluta kaydeder.
3. Ekli Mac, değiştirilen dosyayı iCloud Klasöründe görür ve dosyaya değişiklikleri kopyalamak için Dosya Koordinasyonu'na sahiptir.
4. Dosya Koordinasyonu kullanmayan bir cihaz, dosyada bir 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ın veya Mac'in dosyayı düzenlediğini varsayalım; şimdi değişiklikleri kaybolur ve dosyanın sıralanmamış cihazdan sürümüyle üzerine yazılır. Veri kaybını önlemek için, bulut tabanlı Belgelerle çalışırken Dosya Koordinasyonu şarttır.

UIDocument kullanma

UIDocument geliştirici için tüm ağır işleri yaparak işleri basitleştirir (veya NSDocument macOS'ta). Uygulamanın kullanıcı arabirimini engellemesini engellemek için arka plan kuyruklarıyla yerleşik Dosya Koordinasyonu sağlar.

UIDocument bir Xamarin uygulamasının geliştirme çalışmalarını geliştiricinin gerektirdiği herhangi bir amaç için kolaylaştıran birden çok üst düzey API'yi kullanıma sunar.

Aşağıdaki kod, iCloud'dan metin depolamak ve almak için kullanılabilecek genel bir metin tabanlı belge uygulamak için bir alt sınıfı UIDocument 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
    }
}

Yukarıda GenericTextDocument sunulan sınıf, bir Xamarin.iOS 8 uygulamasında Belge Seçici ve dış Belgeler ile çalışırken bu makale boyunca kullanılacaktır.

Zaman Uyumsuz Dosya Koordinasyonu

iOS 8, yeni Dosya Koordinasyon API'leri aracılığıyla çeşitli yeni Zaman Uyumsuz Dosya Koordinasyon özellikleri sağlar. iOS 8'e geçmeden önce, mevcut tüm Dosya Koordinasyon API'leri tamamen zaman uyumluydu. Bu, geliştiricinin Dosya Koordinasyonu'nun uygulamanın kullanıcı arabirimini engellemesini önlemek için kendi arka plan kuyruğa alma işlemini gerçekleştirmekten sorumlu olduğu anlamına geliyordu.

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

// 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 bulmanın ve listelemenin yolu, mevcut NSMetadataQuery API'leri kullanmaktır. Bu bölümde, Belgelerle çalışmayı eskisinden daha da kolay hale getiren yeni özellikler NSMetadataQuery ele alınacaktır.

Mevcut Davranış

iOS 8'in öncesinde, silme, NSMetadataQuery oluşturma ve yeniden adlandırma gibi yerel dosya değişikliklerini alma işlemi yavaştı.

Yukarıdaki diyagramda:

1. Uygulama Kapsayıcısı'nda zaten var olan dosyalar için, NSMetadataQuery önceden oluşturulmuş ve biriktirilmiş mevcut NSMetadata kayıtlar vardır, böylece bunlar uygulama tarafından anında kullanılabilir.
2. Uygulama, Uygulama Kapsayıcısı'nda yeni bir dosya oluşturur.
3. Uygulama Kapsayıcısı'nın değiştirilmesini görüp gerekli NSMetadata kaydı oluşturmadan önce NSMetadataQuery bir gecikme yaşanır.

Kaydın oluşturulmasındaki NSMetadata gecikme nedeniyle uygulamanın iki veri kaynağının açık olması gerekiyordu: biri yerel dosya değişiklikleri ve biri de bulut tabanlı değişiklikler için.

Dikiş

iOS 8'de, NSMetadataQuery Dikiş adı verilen yeni bir özellik ile doğrudan kullanmak daha kolaydır:

Yukarıdaki diyagramda Dikiş kullanma:

1. Daha önce olduğu gibi, Uygulama Kapsayıcısı'nda NSMetadataQuery zaten var olan dosyalar için önceden oluşturulmuş ve biriktirilmiş mevcut NSMetadata kayıtlar vardır.
2. Uygulama, Dosya Koordinasyonu kullanarak Uygulama Kapsayıcısı'nda yeni bir dosya oluşturur.
3. Uygulama Kapsayıcısı'ndaki bir kanca, değişikliği görür ve gerekli NSMetadata kaydı oluşturmak için çağrılarNSMetadataQuery.
4. Kayıt NSMetadata , doğrudan dosyadan sonra oluşturulur ve uygulamanın kullanımına sunulur.

Stitching kullanarak uygulamanın artık yerel ve bulut tabanlı dosya değişikliklerini izlemek için bir veri kaynağı açması gerekmez. Artık uygulama doğrudan kullanabilir NSMetadataQuery .

Önemli

Birleştirme yalnızca uygulama yukarıdaki bölümde gösterildiği gibi Dosya Koordinasyonu kullanıyorsa çalışır. Dosya Koordinasyonu kullanılmıyorsa, API'ler varsayılan olarak mevcut iOS 8 öncesi davranışına ayarlanır.

Yeni iOS 8 Meta Veri Özellikleri

iOS 8'de NSMetadataQuery aşağıdaki yeni özellikler eklendi:

• NSMetatadataQuery artık bulutta depolanan yerel olmayan belgeleri listeleyebilir.
• Bulut tabanlı belgelerdeki meta veri bilgilerine erişmek için yeni API'ler eklendi.
• İçeriği yerel olarak kullanılabilir olan veya olmayan dosyaların dosya özniteliklerine erişecek yeni NSUrl_PromisedItems bir API vardır.
• GetPromisedItemResourceValue Belirli bir dosya hakkında bilgi almak için yöntemini kullanın veya aynı anda birden fazla dosya hakkında bilgi almak için yöntemini kullanınGetPromisedItemResourceValues.

Meta verilerle ilgilenmek için iki yeni dosya koordinasyon bayrağı eklendi:

• NSFileCoordinatorReadImmediatelyAvailableMetadataOnly
• NSFileCoordinatorWriteContentIndependentMetadataOnly

Yukarıdaki bayraklarla, Belge dosyasının içeriğinin kullanılabilmesi için yerel olarak kullanılabilir olması gerekmez.

Aşağıdaki kod kesimi, belirli bir dosyanın varlığını sorgulamak ve yoksa dosyayı derlemek için nasıl kullanılacağını NSMetadataQuery 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 uygulamanın belgelerini listelerken en iyi kullanıcı deneyiminin önizlemeleri kullanmak olduğunu düşünüyor. Bu, son kullanıcılara, çalışmak istedikleri belgeyi hızla belirleyebilmeleri için bağlam sağlar.

iOS 8'in öncesinde, belge önizlemelerinin gösterilmesi için özel bir uygulama gerekiyordu. iOS 8'de yeni olan dosya sistemi öznitelikleri, geliştiricinin Belge Küçük Resimleri ile hızlı bir şekilde çalışmasını sağlar.

Belge Küçük Resimlerini Alma

veya GetPromisedItemResourceValues yöntemleri NSUrl_PromisedItems çağrılarak GetPromisedItemResourceValue API, bir NSUrlThumbnailDictionarydöndürülür. Şu anda bu sözlükte bulunan tek anahtar ve ile eşleşen UIImageanahtarıdırNSThumbnial1024X1024SizeKey.

Belge Küçük Resimlerini Kaydetme

Küçük resim kaydetmenin en kolay yolu kullanmaktır UIDocument. yöntemini UIDocument çağırıp GetFileAttributesToWrite küçük resmi ayarlayarak, Belge dosyası olduğunda otomatik olarak kaydedilir. iCloud Daemon bu değişikliği görecek ve iCloud'a yayacaktır. Mac OS X'te küçük resimler, Hızlı Görünüm eklentisi tarafından geliştirici için otomatik olarak oluşturulur.

iCloud tabanlı Belgelerle çalışmanın temelleri ve mevcut API'de yapılan değişikliklerle birlikte, Xamarin iOS 8 Mobil Uygulamasında Belge Seçici Görünüm Denetleyicisi'ni uygulamaya hazırız.

Xamarin'de iCloud'un etkinleştirilmesi

Belge Seçici'nin bir Xamarin.iOS Uygulamasında kullanılabilmesi için önce iCloud desteğinin hem uygulamanızda hem de Apple aracılığıyla etkinleştirilmesi gerekir.

Aşağıdaki adımlar, iCloud için sağlama işlemine ilişkin adım izlenecek yol.

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

Özelliklerle Çalışma kılavuzu ilk iki adımda yol gösterir. Sağlama profili oluşturmak için Sağlama Profili kılavuzundaki adımları izleyin.

Aşağıdaki adımlar, uygulamanızı iCloud için yapılandırma işleminde izlenecek yol:

Aşağıdakileri yapın:

1. Projeyi Mac için Visual Studio veya Visual Studio'da açın.

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

3. Seçenekler İletişim Kutusunda iOS Uygulaması'nı seçin, Paket Tanımlayıcısı'nınuygulama için yukarıda oluşturulan Uygulama Kimliği'nde tanımlananla eşleştiğinden emin olun.

4. iOS Paket İmzalama'yı seçin, geliştirici kimliğini ve yukarıda oluşturulan Sağlama Profili'ni seçin.

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

6. düzenleyicide açmak için Çözüm Gezgini sağ tıklayınEntitlements.plist.

   Önemli

   Visual Studio'da, Sağ tıklayıp Birlikte Aç... seçeneğini belirleyip Özellik Listesi Düzenleyicisi'ni seçerek Yetkilendirmeler düzenleyicisini açmanız gerekebilir

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

8. Uygulama için Kapsayıcının mevcut olduğundan emin olun (yukarıda oluşturulduğu gibi). Ö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 kurulum gerçekleştirildikten sonra uygulama artık bulut tabanlı belgeleri ve yeni Belge Seçici Görünüm Denetleyicisi'ni kullanabilir.

Ortak Kurulum Kodu

Belge Seçici Görünüm Denetleyicisi'ni kullanmaya başlamadan önce bazı standart kurulum kodları gereklidir. Uygulamanın AppDelegate.cs dosyasını değiştirerek başlayın ve aşağıdaki gibi görünmesini sağlayın:

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
    }
}

Önemli

Yukarıdaki kod, yukarıdaki Belgeleri Bulma ve Listeleme bölümünde yer alan kodu içerir. Burada, gerçek bir uygulamada göründüğü gibi tamamen sunulur. Kolaylık olması için, bu örnek yalnızca sabit kodlanmış tek bir dosyayla (test.txt) çalışır.

Yukarıdaki kod, uygulamanın geri kalanında çalışmayı kolaylaştırmak için çeşitli iCloud Drive kısayollarını kullanıma sunar.

Ardından, Belge Seçici'yi kullanacak veya bulut tabanlı belgelerle çalışacak herhangi bir görünüme veya görünüm kapsayıcısına aşağıdaki kodu 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, öğesine ulaşmak ve yukarıda oluşturulan iCloud kısayollarına erişmek için AppDelegate bir kısayol ekler.

Bu kod uygulandığında, Xamarin iOS 8 uygulamasında Belge Seçici Görünüm Denetleyicisi'ni uygulama konusuna göz atalım.

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

iOS 8'den önce başka bir uygulamadan Belgelere erişmek çok zordu çünkü uygulamanın dışındaki belgeleri uygulamanın içinden bulmanın bir yolu yoktu.

Mevcut Davranış

Şimdi iOS 8'in öncesinde bir dış belgeye erişmeye göz atalım:

1. İlk olarak kullanıcının belgeyi ilk oluşturan uygulamayı açması gerekir.
2. Belge seçilir 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ı'na yerleştirilir.

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

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

iOS 8'de bir uygulama, Belgelere kendi Uygulama Kapsayıcısı dışında kolayca erişebilir:

Yeni iCloud Belge Seçicisi ' ni ( UIDocumentPickerViewController) kullanarak bir iOS uygulaması, Uygulama Kapsayıcısı'nın dışında doğrudan bulabilir ve bu uygulamaya erişebilir. , UIDocumentPickerViewController kullanıcının izinler aracılığıyla bulunan Belgelere erişim vermesine ve bunları düzenlemesine yönelik bir mekanizma sağlar.

Bir uygulamanın, belgelerinin iCloud Belge Seçici'de gösterilmesini ve diğer uygulamaların bunları keşfedip bunlarla çalışabilmesi için kabul etmesi gerekir. Bir Xamarin iOS 8 uygulamasının Uygulama Kapsayıcısını paylaşmasını sağlamak için, dosyayı standart bir metin düzenleyicisinde düzenleyin Info.plist ve sözlüğün altına aşağıdaki iki satırı ekleyin (etiketler arasında <dict>...</dict> ):

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

, UIDocumentPickerViewController kullanıcının belgeleri seçmesine olanak tanıyan harika bir yeni kullanıcı arabirimi sağlar. Xamarin iOS 8 uygulamasında Belge Seçici Görünüm Denetleyicisi'ni görüntülemek için aşağıdakileri 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;
}

Önemli

Bir dış belgeye erişilmeden önce geliştiricinin NSUrl yöntemini çağırması StartAccessingSecurityScopedResource gerekir. StopAccessingSecurityScopedResource Belge yüklenir yüklenmez güvenlik kilidini serbest bırakmak için yöntemi çağrılmalıdır.

Örnek Çıkış

Yukarıdaki kodun i Telefon cihazında çalıştırıldığında belge seçiciyi nasıl görüntüleyeceğini gösteren bir örnek aşağıda verilmiştir:

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

   

2. Kullanıcı ekranın üst kısmındaki Eylem Düğmesine dokunur ve kullanılabilir sağlayıcılar listesinden bir Belge Sağlayıcısı seçmesi istenir:

   

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

   

4. Kullanıcı, içeriğini görüntülemek için belge klasörüne dokunur:

   

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

6. Ana arabirim yeniden dağıtılır, 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üklediği Belge Sağlayıcılarına ve hangi Belge Seçici Modu'nun uygulandığına 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ınacaktır.

Dış Belgeleri Yönetme

Yukarıda açıklandığı gibi, iOS 8'in öncesinde bir uygulama yalnızca Uygulama Kapsayıcısı'nın bir parçası olan belgelere erişebilirdi. iOS 8'de bir uygulama dış kaynaklardan Belgelere erişebilir:

Kullanıcı dış kaynaktan bir Belge seçtiğinde, Uygulama Kapsayıcısı'na özgün Belgeyi gösteren bir Başvuru Belgesi yazılır.

Bu yeni özelliği mevcut uygulamalara eklemeye yardımcı olmak için API'ye NSMetadataQuery birkaç yeni özellik eklendi. Genellikle bir uygulama, Uygulama Kapsayıcısı içinde bulunan belgeleri listelemek için Yaygın Belge Kapsamı'nı kullanır. Bu kapsam kullanıldığında, yalnızca Uygulama Kapsayıcısı içindeki belgeler görüntülenmeye devam eder.

Yeni Yaygın Dış Belge Kapsamı kullanıldığında, Uygulama Kapsayıcısı'nın dışında kalan belgeler döndürülecek ve bunlar için meta veriler döndürülecektir. , NSMetadataItemUrlKey Belgenin gerçekten bulunduğu URL'ye işaret eder.

Bazen bir uygulama, th başvurusuyla işaret edilen Belgelerle çalışmak istemez. Bunun yerine, uygulama doğrudan Başvuru Belgesi ile çalışmak istiyor. Örneğin, uygulama belgeyi kullanıcı arabirimindeki Uygulama klasöründe görüntülemek veya kullanıcının başvuruları bir klasörün içinde taşımasına izin vermek isteyebilir.

iOS 8'de, Başvuru Belgesi'ne doğrudan erişmek için yeni NSMetadataItemUrlInLocalContainerKey bir sağlanmıştır. Bu anahtar, Bir Uygulama Kapsayıcısı'ndaki dış belgenin gerçek başvurusunu 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ı barındıran Kapsayıcının 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ı kullanmasının temel nedeni güvenliktir. Hiçbir uygulamaya başka bir uygulamanın Kapsayıcısına erişim verilmez. İşlem süresi dolacağından ve sistem genelinde erişime sahip olduğundan, bunu yalnızca Belge Seçici yapabilir.

Uygulama Kapsayıcısı dışındaki bir belgeye ulaşmak için Tek yol, Belge Seçici'yi kullanmak ve seçici tarafından döndürülen URL'nin Güvenlik Kapsamlı olmasıdır. Güvenlik Kapsamlı URL'si, belgeye uygulama erişimi vermek için gereken kapsamlı hakların yanı sıra belgeyi seçmek için yeterli bilgi içerir.

Güvenlik Kapsamlı URL'nin bir dizede seri hale getirilip sonra seri durumdan çıkarılmış olması durumunda, Güvenlik Bilgileri'nin kaybolacağını ve dosyanın URL'den erişilemez olacağını unutmayın. Belge Başvurusu özelliği, bu URL'lerin işaret ettiği dosyalara geri dönmek için bir mekanizma sağlar.

Bu nedenle, uygulama Başvuru Belgelerinden birinden bir NSUrl alırsa, güvenlik kapsamı zaten eklenmiştir ve dosyaya erişmek için kullanılabilir. Bu nedenle, geliştiricinin bu bilgilerin ve işlemlerin tümünü işlediği için kullanması UIDocument kesinlikle önerilir.

Yer İşaretlerini Kullanma

Örneğin, durum geri yükleme yaparken belirli bir Belgeye geri dönmek için uygulamanın Belgelerini listelemek her zaman mümkün değildir. iOS 8, belirli bir Belgeyi doğrudan hedefleyen Yer İşaretleri oluşturmak için bir mekanizma sağlar.

Aşağıdaki kod bir özelliğinden FileUrl yer UIDocumentişareti oluşturur:

// 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);
}

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

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 ve Belge Seçici karşılaştırması

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

1. Açma Modu – Bu modda, kullanıcı belgeyi ve dış belgeyi seçtiğinde, Belge Seçici Uygulama Kapsayıcısı'nda Bir Güvenlik Kapsamlı Yer İşareti oluşturur.

   

2. İçeri Aktarma Modu – Bu modda, kullanıcı belgeyi seçtiğinde ve dış Belgeyi seçtiğinde, Belge Seçici bir Yer İşareti oluşturmaz, bunun yerine dosyayı Geçici Konum'a kopyalayıp bu konumdaki Belgeye uygulama erişimi sağlar:

   
   Uygulama herhangi bir nedenle sonlandırıldıktan sonra Geçici Konum boşaltılır ve dosya kaldırılır. Uygulamanın dosyaya erişimi sürdürmesi gerekiyorsa, bir kopya oluşturup Uygulama Kapsayıcısı'na yerleştirmesi gerekir.

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

Dış Belge Oluşturma

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

Belgeyi dış konuma taşımak için aşağıdakileri yapın:

1. İlk olarak yerel veya geçici bir konumda yeni bir Belge oluşturun.
2. Yeni Belgeye işaret eden bir NSUrl oluşturun.
3. Yeni bir Belge Seçici Görünüm Denetleyicisi açın ve NSUrl Modu MoveToService ile geçirin.
4. Kullanıcı yeni bir konum seçtikten sonra, Belge geçerli konumundan yeni konuma taşınır.
5. Uygulamanın Uygulama Kapsayıcısına bir Başvuru Belgesi yazılır, böylece dosyaya oluşturma uygulaması tarafından yine erişilebilir.

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 başvuruyu tutmadan belgeyi taşımak isteyebileceği zamanlar olabilir.

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

Modu kullanırken ExportToService , Belge dış Kapsayıcıya kopyalanır ve var olan kopya özgün konumunda bırakılır.

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

iOS 8 ile Apple, son kullanıcının gerçekten nerede olursa olsun bulut tabanlı belgelerinden herhangi birine erişebilmesini 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 belirtmek gerekirse, Belge Sağlayıcısı Uzantısı bir geliştiricinin veya üçüncü tarafın, mevcut iCloud depolama konumuyla tam olarak aynı şekilde erişilebilen bir uygulamaya alternatif belge depolama alanı sağlamanın bir yoludur.

Kullanıcı, Belge Seçici'den bu alternatif depolama konumlarından birini seçebilir ve bu konumdaki dosyalarla çalışmak için tam olarak aynı erişim modlarını (Aç, İçeri, 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 UIViewController depolama konumundan 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 Sağlama Uzantısı – Bu, dosya içeriğinin gerçekten sağlanmasıyla ilgilenen kullanıcı arabirimi olmayan bir uzantıdır. Bu uzantılar Dosya Koordinasyonu ( NSFileCoordinator ) aracılığıyla 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österilmektedir:

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

1. Uygulama, kullanıcının çalışmak üzere bir dosya seçmesine izin vermek için bir Belge Seçici Denetleyicisi sunar.
2. Kullanıcı alternatif bir dosya konumu seçer ve kullanıcı arabirimini görüntülemek için özel UIViewController uzantı çağrılır.
3. Kullanıcı bu konumdan bir dosya seçer ve URL Belge Seçici'ye geri geçirilir.
4. Belge Seçici, dosyanın URL'sini seçer ve kullanıcının üzerinde çalışması için bu URL'yi uygulamaya döndürür.
5. Url, dosya içeriğini uygulamaya döndürmek için Dosya Düzenleyicisi'ne geçirilir.
6. Dosya Düzenleyicisi, dosyayı almak için özel Dosya Sağlayıcısı Uzantısını çağırır.
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üvenlik ve kalıcı dosya erişiminin Belge Sağlayıcısı Uzantıları ile nasıl çalıştığına hızlı bir bakış sağlayacaktır. Güvenlik ve Yer İşaretlerini uygulama kapsayıcısı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ı olmadıklarından bunu yapamaz.

Örneğin: Şirket genelinde kendi güvenli veri deposunu sağlayan kurumsal bir ayarda, yöneticiler gizli şirket bilgilerine genel iCloud Sunucuları tarafından erişılmasını veya işlenmesini istemez. Bu nedenle, yerleşik Belge Başvuru Sistemi kullanılamaz.

Yer İşareti sistemi hala kullanılabilir ve yer işareti uygulanmış bir URL'yi doğru şekilde işlemek ve belgenin işaret ettiği belgenin içeriğini döndürmek Dosya Sağlayıcısı Uzantısı'nın sorumluluğundadır.

iOS 8, güvenlik amacıyla hangi uygulamanın hangi Dosya Sağlayıcısı içinde hangi tanımlayıcıya erişimi olduğuna ilişkin bilgileri kalıcı hale getiren bir Yalıtım Katmanına sahiptir. Tüm dosya erişiminin bu Yalıtım Katmanı tarafından denetlendiği belirtilmelidir.

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

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

1. Uygulama arka plana girmek üzere ve durumunu kalıcı hale getirmek istiyor. Alternatif depolamadaki bir dosyaya yer işareti oluşturmayı çağırır NSUrl .
2. NSUrl Belgenin kalıcı URL'sini almak için Dosya Sağlayıcısı Uzantısı'nı çağırır.
3. Dosya Sağlayıcısı Uzantısı URL'yi dizesi NSUrl olarak döndürür.
4. URL'yi NSUrl yer işaretine paketler ve uygulamaya döndürür.
5. Uygulama arka planda olmaktan çıktığında ve durumu geri yüklemesi gerektiğinde Yer İşareti'ni öğesine NSUrl geçirir.
6. NSUrl dosyanın URL'si ile Dosya Sağlayıcısı Uzantısı'nı çağırır.
7. Dosya Uzantısı Sağlayıcısı dosyaya erişir ve dosyanın konumunu olarak NSUrl döndürür.
8. Dosya konumu güvenlik bilgileriyle birlikte verilir ve uygulamaya döndürülür.

Buradan uygulama dosyaya erişebilir ve dosyayla normal şekilde çalışabilir.

Dosya Yazma

Bu bölüm, Belge Sağlayıcısı Uzantısı ile alternatif bir konuma dosya yazmanın nasıl çalıştığına hızlı bir bakış sağlar. iOS uygulaması, Uygulama Kapsayıcısı içindeki diske bilgi kaydetmek için Dosya Koordinasyonu'nı kullanır. Dosya başarıyla yazıldıktan kısa bir süre sonra Dosya Sağlayıcısı Uzantısına değişiklik bildirilir.

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şaretleyebilir).

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

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

Geliştirici, Belge Seçici'yi kullanırken ve dış Belgelerle çalışırken bu gerçeğin farkında olmalıdır. Bu Belgenin iCloud'da barındırılıyor olduğunu varsaymamalıdırlar.

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 Drive'a geçiş

iOS 8'de, kullanıcılar iOS 7'de (ve önceki sistemlerde) kullanılan mevcut iCloud Belgeleri Sistemi'ni kullanmaya devam etmeyi veya mevcut Belgeleri yeni iCloud Drive mekanizmasına geçirmeyi seçebilir.

Mac OS X Yosemite'da Apple geriye dönük uyumluluk sağlamaz, bu nedenle tüm belgelerin iCloud Drive'a geçirilmesi gerekir, aksi takdirde cihazlar arasında artık güncelleştirilmeyecektir.

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

Önemli

Geliştiriciler, bu makalede ele alınan yeni özelliklerin yalnızca kullanıcının hesabı iCloud Drive'a geçirilmişse kullanılabilir olduğunu bilmeli.

Özet

Bu makalede, iCloud Drive'ı ve yeni Belge Seçici Görünüm Denetleyicisi'ni desteklemek için gereken mevcut iCloud API'lerine yapılan değişiklikler ele alınmıştır. Dosya Koordinasyonu ve bulut tabanlı belgelerle çalışırken neden önemli olduğu ele alınmıştır. Xamarin.iOS Uygulamasında bulut tabanlı belgeleri etkinleştirmek için gereken kurulumu ele almıştır ve Belge Seçici Görünüm Denetleyicisi'ni kullanarak uygulamanın Uygulama Kapsayıcısı dışındaki belgelerle çalışmaya giriş niteliğinde bir bakış sağlamıştır.

Buna ek olarak, bu makalede Belge Sağlayıcısı Uzantıları ve bulut tabanlı belgeleri işleyebilen uygulamalar yazarken geliştiricinin bunları neden bilmesi gerektiği kısaca ele alınmıştır.

İlişkili Bağlantılar

• iOS 8’e Giriş
• Uygulama Uzantılarına Giriş