Předání v Xamarin. iOSHandoff in Xamarin.iOS

Tento článek popisuje práci s předáním do aplikace Xamarin. iOS pro přenos aktivit uživatelů mezi aplikacemi spuštěnými na jiných zařízeních uživatele.This article covers working with Handoff in a Xamarin.iOS app to transfer user activities between apps running on the user's other devices.

Společnost Apple zavedla odložení v iOS 8 a OS X Yosemite (10,10), aby poskytovala společný mechanismus, který uživateli umožňuje přenést aktivity spuštěné na jednom ze svých zařízení, do jiného zařízení, ve kterém je spuštěná stejná aplikace nebo jiná aplikace, která podporuje stejnou aktivitu.Apple introduced Handoff in iOS 8 and OS X Yosemite (10.10) to provide a common mechanism for the user to transfer activities started on one of their devices, to another device running the same app or another app that supports the same activity.

Příklad provádění operace předáníAn example of performing a Handoff operation

V tomto článku se podíváme na to, jak povolit sdílení aktivit v aplikaci Xamarin. iOS a podrobně pokrývající rozhraní pro předání:This article will take a quick look at enabling activity sharing in a Xamarin.iOS app and cover the Handoff framework in detail:

O předáníAbout Handoff

Předání (známé také jako kontinuita) bylo zavedeno společností Apple v systému iOS 8 a OS X Yosemite (10,10) jako způsob, jak může uživatel spustit aktivitu na jednom ze svých zařízení (buď iOS nebo Mac), a pokračovat v této stejné aktivitě na jiném zařízení (jak identifikuje účet iCloud uživatele).Handoff (also known as Continuity) was introduced by Apple in iOS 8 and OS X Yosemite (10.10) as a way for the user to start an activity on one of their devices (either iOS or Mac) and continue that same activity on another of their devices (as identified by the user's iCloud Account).

Přeložení bylo rozšířeno v systému iOS 9 a podporuje také nové a rozšířené možnosti vyhledávání.Handoff was expanded in iOS 9 to also support new, enhanced Search capabilities. Další informace najdete v dokumentaci k vylepšením vyhledávání .For more information, please see our Search Enhancements documentation.

Uživatel může třeba na svém iPhonu zahájit e-mail a bez problémů pokračovat v e-mailu na svém Macu se všemi informacemi o stejné zprávě, které jsou vyplněné, a kurzorem ve stejném umístění, ve kterém ho opustili v iOS.For example, the user can start an email on their iPhone and seamlessly continue the email on their Mac, with all of the same message information filled in and the cursor in the same location that they left it in iOS.

Každá z vašich aplikací, které sdílejí stejné ID týmu , mají nárok na použití předávaných dat, aby bylo možné pokračovat v činnosti uživatelů napříč aplikacemi, pokud jsou tyto aplikace dodávány buď prostřednictvím aplikace iTunes App Store, nebo podepsané vývojářem (pro aplikace pro Mac, podnikové nebo ad hoc).Any of your apps that share the same Team ID are eligible for using Handoff to continue user activities across apps as long as these app are either delivered via the iTunes App Store or signed by a registered developer (for Mac, Enterprise or Ad Hoc apps).

NSDocumentAplikace nebo UIDocument aplikace založené na této aplikaci automaticky přecházejí na integrovanou podporu a vyžadují minimální změny, aby bylo možné podporu odkládat.Any NSDocument or UIDocument based apps automatically have Handoff support built-in, and require minimal changes to support Handoff.

Pokračování aktivit uživatelůContinuing User Activities

NSUserActivityTřída (spolu s některými malými změnami v systémech UIKit a AppKit ) poskytuje podporu pro definování aktivity uživatele, která může být potenciálně pokračování na jiném zařízení uživatele.The NSUserActivity class (along with some small changes to UIKit and AppKit) provides support for defining a user's activity that can potentially be continued on another of the user's devices.

Aby byla aktivita předána do jiné části zařízení uživatele, musí být zapouzdřovaná v instanci, která je NSUserActivity označena jako aktuální aktivita, měla pro ni nastavenou datovou sadu (data použitá k provedení pokračování) a aktivitu je pak nutné přenést do tohoto zařízení.For an activity to be passed over to another of the user's devices, it must be encapsulated in an instance NSUserActivity, marked as the Current Activity, have it's payload set (the data used to perform the continuation) and the activity must then be transmitted to that device.

Při předání se předá informace o tom, jak definovat aktivitu, která se má pokračovat. větší datové pakety se synchronizují prostřednictvím iCloud.Handoff passes the bare minimum of information to define the activity to be continued, with larger data packets being synced via iCloud.

Na přijímajícím zařízení dostane uživatel oznámení, že je aktivita k dispozici pro pokračování.On the receiving device, the user will receive a notification that an activity is available for continuation. Pokud se uživatel rozhodne pokračovat v aktivitě na novém zařízení, zadaná aplikace se spustí (Pokud ještě není spuštěná) a datová část z nástroje NSUserActivity slouží k restartování aktivity.If the user chooses to continue the activity on the new device, the specified app is launched (if not already running) and the payload from the NSUserActivity is used to restart the activity.

Přehled pokračujících aktivit uživatelůAn overview of Continuing User Activities

Na pokračování mají nárok pouze aplikace, které sdílejí stejné ID vývojářského týmu a reagují na daný typ aktivity .Only apps that share the same developer Team ID and respond to a given Activity Type are eligible for continuation. Aplikace definuje typy aktivity, které podporuje pod NSUserActivityTypes klíčem jeho souboru info. plist .An app defines the Activity Types that it supports under the NSUserActivityTypes key of its Info.plist file. V takovém případě pokračuje zařízení zvolit aplikaci k provedení pokračování na základě ID týmu, typu aktivity a volitelně názvu aktivity.Given this, a continuing device chooses the app to perform the continuation based on the Team ID, Activity Type and optionally the Activity Title.

Přijímající aplikace používá informace ze NSUserActivity UserInfo slovníku ke konfiguraci uživatelského rozhraní a obnoví stav dané aktivity tak, aby byl přechod pro koncového uživatele bezproblémově zobrazen.The receiving app uses information from the NSUserActivity's UserInfo dictionary to configure its user interface and restore the state of the given activity so that the transition appears seamless to the end user.

Pokud pokračování vyžaduje více informací, než je možné efektivně odeslat prostřednictvím NSUserActivity , pokračování aplikace může poslat volání zdrojové aplikace a vytvořit jeden nebo více datových proudů pro přenos požadovaných dat.If the continuation requires more information than can be sent efficiently through a NSUserActivity, the resuming app can send a call to the originating app and establish one or more streams to transmit the required data. Pokud například aktivita upravuje velký textový dokument s více obrázky, bude pro přenos informací potřebných k pokračování aktivity na přijímajícím zařízení nutné streamování.For example, if the activity was editing a large text document with multiple images, streaming would be required to transfer the information needed to continue the activity on the receiving device. Další informace najdete níže v části podporované streamy pro pokračování .For more information, see the Supporting Continuation Streams section below.

Jak je uvedeno výše, NSDocument nebo UIDocument aplikace založené na této aplikaci automaticky přecházejí na integrovanou podporu.As stated above, NSDocument or UIDocument based apps automatically have Handoff support built-in. Další informace najdete v části Podpora odložení v aplikacích založených na dokumentech níže.For more information, see the Supporting Handoff in Document-Based Apps section below.

Třída NSUserActivityThe NSUserActivity Class

NSUserActivityTřída je primární objekt v předaném Exchangi a slouží k zapouzdření stavu aktivity uživatele, která je k dispozici pro pokračování.The NSUserActivity class is the primary object in a Handoff exchange and is used to encapsulate the state of a User Activity that is available for continuation. Aplikace vytvoří instanci kopie NSUserActivity pro libovolnou aktivitu, kterou podporuje, a chce pokračovat na jiném zařízení.An app will instantiate a copy of NSUserActivity for any activity it supports and wishes to continue on another device. Editor dokumentů například vytvoří aktivitu pro každý dokument, který je aktuálně otevřen.For example, document editor would create an activity for each document currently open. Ale pouze přední dokument (zobrazený v předním okně nebo na kartě) je aktuální aktivita , která je k dispozici pro pokračování.However, only the frontmost document (displayed in the frontmost Window or Tab) is the Current Activity and therefor available for continuation.

Instance NSUserActivity je identifikována svými ActivityType Title vlastnostmi a.An instance of NSUserActivity is identified by both its ActivityType and Title properties. UserInfoVlastnost Dictionary slouží k přenosu informací o stavu aktivity.The UserInfo dictionary property is used to carry information about the state of the activity. Nastavte vlastnost na hodnotu, pokud chcete, aby NeedsSave true byly informace o stavu opožděně načteny prostřednictvím NSUserActivity delegáta.Set the NeedsSave property to true if you want to lazy load the state information via the NSUserActivity's delegate. Pomocí AddUserInfoEntries metody můžete sloučit nová data z jiných klientů do UserInfo slovníku podle potřeby, aby se zachoval stav aktivity.Use the AddUserInfoEntries method to merge new data from other clients into the UserInfo dictionary as required to preserve the activity's state.

Třída NSUserActivityDelegateThe NSUserActivityDelegate Class

NSUserActivityDelegateSlouží k uchovávání informací ve NSUserActivity UserInfo slovníku a v synchronizaci s aktuálním stavem aktivity.The NSUserActivityDelegate is used to keep information in a NSUserActivity's UserInfo dictionary up-to-date and in sync with the current state of the activity. Když systém potřebuje informace v aktivitě, která se má aktualizovat (například před pokračováním na jiném zařízení), zavolá UserActivityWillSave metodu delegáta.When the system needs the information in the activity to be updated (such as before continuation on another device), it calls the UserActivityWillSave method of the delegate.

Bude nutné implementovat UserActivityWillSave metodu a provést jakékoli změny NSUserActivity (například UserInfo , atd.), aby se Title zajistilo, že stále odráží stav aktuální aktivity.You will need to implement the UserActivityWillSave method and make any changes to the NSUserActivity (such as UserInfo, Title, etc.) to ensure that it still reflects the state of the Current Activity. Když systém zavolá UserActivityWillSave metodu, NeedsSave příznak se nevymaže.When the system calls the UserActivityWillSave method, the NeedsSave flag will be cleared. Pokud upravíte jakékoli vlastnosti dat aktivity, budete muset nastavit NeedsSave na true znovu.If you modify any of the data properties of the activity, you'll need to set NeedsSave to true again.

Místo používání UserActivityWillSave výše uvedené metody můžete volitelně taky UIKit nebo AppKit Spravovat aktivity uživatelů automaticky.Instead of using the UserActivityWillSave method presented above, you can optionally have UIKit or AppKit manage the user activity automatically. Provedete to tak, že nastavíte UserActivity vlastnost objektu Responder a implementujete UpdateUserActivityState metodu.To do this, set the responder object's UserActivity property and implement the UpdateUserActivityState method. Další informace najdete v části Podpora předávaných v níže uvedených odezvách .See the Supporting Handoff in Responders section below for more information.

Podpora rozhraní App FrameworkApp Framework Support

Obě UIKit (iOS) i AppKit (OS X) poskytují integrovanou podporu pro předávání v NSDocument , respondérech UIResponder / NSResponder a AppDelegate třídách.Both UIKit (iOS) and AppKit (OS X) provide built-in support for Handoff in the NSDocument, Responder (UIResponder/NSResponder), and AppDelegate classes. Zatímco jednotlivé operační systémy implementují mírně odlišně, základní mechanismus a rozhraní API jsou stejné.While each OS implements Handoff slightly differently, the basic mechanism and the APIs are the same.

Aktivity uživatelů v aplikacích založených na dokumentechUser Activities in Document-Based Apps

Aplikace pro iOS a OS X v dokumentu automaticky přecházejí na integrovanou podporu.Document-based iOS and OS X apps automatically have Handoff support built-in. Pokud chcete aktivovat tuto podporu, budete muset přidat NSUbiquitousDocumentUserActivityType klíč a hodnotu pro každou CFBundleDocumentTypes položku v souboru info. plist aplikace.To activate this support, you'll need to add an NSUbiquitousDocumentUserActivityType key and value for each CFBundleDocumentTypes entry in the app's Info.plist file.

Pokud je tento klíč přítomen, NSDocument a UIDocument automaticky vytvoří NSUserActivity instance pro dokumenty založené na iCloud typu.If this key is present, both NSDocument and UIDocument automatically create NSUserActivity instances for iCloud-based documents of the type specified. Budete muset zadat typ aktivity pro každý typ dokumentu, který podporuje aplikace, a více typů dokumentů může používat stejný typ aktivity.You will need to provide an activity type for each type of document that the app supports and multiple document types can use the same activity type. NSDocumentA UIDocument automaticky naplní UserInfo vlastnost NSUserActivity s FileURL hodnotou jejich vlastnosti.Both NSDocument and UIDocument automatically populate the UserInfo property of the NSUserActivity with their FileURL property's value.

V OS X se aplikace NSUserActivity spravované pomocí AppKit a přidružená k odesilatelům automaticky stane aktuální aktivitou, když se okno dokumentu stane hlavním oknem.On OS X, the NSUserActivity managed by AppKit and associated with responders automatically become the Current Activity when the document’s window becomes the main window. V systému iOS pro NSUserActivity objekty UIKit , které jsou spravovány nástrojem, je nutné zavolat BecomeCurrent metodu explicitně nebo nechat UserActivity vlastnost dokumentu nastavenou na hodnotu, UIViewController když aplikace přichází do popředí.On iOS, for NSUserActivity objects managed by UIKit, you must either call BecomeCurrent method explicitly or have the document’s UserActivity property set on a UIViewController when the app comes to the foreground.

AppKit automaticky obnoví všechny UserActivity Vlastnosti vytvořené tímto způsobem v OS X. K tomu dojde, pokud ContinueUserActivity Metoda vrátí false nebo pokud je neimplementovaná.AppKit will automatically restore any UserActivity property created in this way on OS X. This occurs if the ContinueUserActivity method returns false or if it is unimplemented. V této situaci je dokument otevřen s OpenDocument metodou NSDocumentController a poté obdrží RestoreUserActivityState volání metody.In this situation, the document is opened with the OpenDocument method of the NSDocumentController and it will then receive a RestoreUserActivityState method call.

Další informace najdete v části Podpora odhlašování v aplikacích založených na dokumentech níže.See the Supporting Handoff in Document-Based Apps section below for more information.

Aktivity a reakce uživatelůUser Activities and Responders

UIKitA AppKit můžou automaticky spravovat aktivitu uživatelů, pokud ji nastavíte jako vlastnost objektu respondéru UserActivity .Both UIKit and AppKit can automatically manage a user activity if you set it as a responder object’s UserActivity property. Pokud byl změněn stav, budete muset nastavit NeedsSave Vlastnost odpovídajícího objektu UserActivity na true .If the state has been modified, you'll need to set the NeedsSave property of the responder's UserActivity to true. Systém bude v UserActivity případě potřeby automaticky ukládat, a to po poskytnutí času respondéra k aktualizaci stavu voláním UpdateUserActivityState metody.The system will automatically save the UserActivity when required, after giving the responder time to update the state by calling its UpdateUserActivityState method.

Pokud více reakcí nasdílí jednu NSUserActivity instanci, obdrží UpdateUserActivityState zpětné volání, když systém aktualizuje objekt aktivity uživatele.If multiple responders share a single NSUserActivity instance, they receive an UpdateUserActivityState callback when the system updates the user activity object. Aby AddUserInfoEntries NSUserActivity UserInfo odrážela aktuální stav aktivity v tomto okamžiku, musí respondér zavolat metodu k aktualizaci slovníku.The responder needs to call the AddUserInfoEntries method to update the NSUserActivity's UserInfo dictionary to reflect the current activity state at this point. UserInfoSlovník je vymazán před každým UpdateUserActivityState voláním.The UserInfo dictionary is cleared before each UpdateUserActivityState call.

Chcete-li zrušit přidružení k aktivitě, respondér může nastavit jeho UserActivity vlastnost na hodnotu null .To disassociate itself from an activity, a responder can set its UserActivity property to null. Když spravovaná instance rozhraní App Framework NSUserActivity nemá žádné přidružené odpovědi nebo dokumenty, je automaticky zrušena.When an app framework managed NSUserActivity instance has no more associated responders or documents, it is automatically invalidated.

Další informace najdete v části Podpora předávaných v níže uvedených odezvách .See the Supporting Handoff in Responders section below for more information.

Aktivity uživatelů a AppDelegateUser Activities and the AppDelegate

Vaše aplikace AppDelegate je svým primárním vstupním bodem při zpracování pokračování při předání.Your app's AppDelegate is its primary entry point when handling a Handoff continuation. Když uživatel odpoví na oznámení o předání, spustí se příslušná aplikace (Pokud ještě není spuštěná) a WillContinueUserActivityWithType Metoda AppDelegate bude volána.When the user responds to a Handoff notification, the appropriate app is launched (if not already running) and the WillContinueUserActivityWithType method of the AppDelegate will be called. V tuto chvíli by aplikace měla informovat uživatele o tom, že se pokračování spouští.At this point, the app should inform the user that the continuation is starting.

NSUserActivityInstance se doručí při AppDelegate ContinueUserActivity volání metody.The NSUserActivity instance is delivered when the AppDelegate's ContinueUserActivity method is called. V tuto chvíli byste měli nakonfigurovat uživatelské rozhraní aplikace a pokračovat v dané aktivitě.At this point, you should configure the app's user interface and continue the given activity.

Další informace najdete v části implementace předání dál.See the Implementing Handoff section below for more information.

Povolení předání v aplikaci XamarinEnabling Handoff in a Xamarin App

Z důvodu požadavků na zabezpečení, které jsou zavedeny předáním, musí být aplikace Xamarin. iOS, která používá předávající rozhraní, správně nakonfigurovaná na portálu pro vývojáře Apple i v souboru projektu Xamarin. iOS.Because of the security requirements imposed by Handoff, a Xamarin.iOS app that uses the Handoff framework must be properly configured in both the Apple Developer Portal and in the Xamarin.iOS project file.

Postupujte následovně:Do the following:

  1. Přihlaste se k portálu pro vývojáře Apple.Log into the Apple Developer Portal.

  2. Klikněte na certifikáty, identifikátory & profily.Click on Certificates, Identifiers & Profiles.

  3. Pokud jste to ještě neudělali, klikněte na identifikátory a vytvořte ID vaší aplikace (např. com.company.appname ), jinak upravte stávající ID.If you haven't already done so, click on Identifiers and create an ID for your app (e.g. com.company.appname), else edit your existing ID.

  4. Ujistěte se, že je pro dané ID zaškrtnutá služba iCloud :Ensure that the iCloud service has been checked for the given ID:

    Povolit službu iCloud pro dané IDEnable the iCloud service for the given ID

  5. Uložte provedené změny.Save your changes.

  6. Klikněte na zřizování profilů > provývoj a vytvořte nový profil pro vývoj pro vaši aplikaci:Click on Provisioning Profiles > Development and create a new development provisioning profile for you app:

    Vytvoření nového vývojového zřizovacího profilu pro aplikaciCreate a new development provisioning profile for the app

  7. Stáhněte si a nainstalujte nový zřizovací profil, nebo použijte ke stažení a instalaci profilu možnost Xcode.Either download and install the new provisioning profile or use Xcode to download and install the profile.

  8. Upravte možnosti projektu Xamarin. iOS a ujistěte se, že používáte zřizovací profil, který jste právě vytvořili:Edit your Xamarin.iOS project options and ensure that you are using the provisioning profile that you just created:

    Vyberte zřizovací profil, který jste právě vytvořili.Select the provisioning profile just created

  9. Dále upravte soubor info. plist a ujistěte se, že používáte ID aplikace, které bylo použito k vytvoření zřizovacího profilu:Next, edit your Info.plist file and ensure that you are using the App ID that was used to create the provisioning profile:

    Nastavit ID aplikaceSet App ID

  10. Přejděte do části režimy pozadí a podívejte se na následující položky:Scroll to the Background Modes section and check the following items:

    Povolit požadované režimy pozadíEnable the required background modes

  11. Uložte změny do všech souborů.Save the changes to all files.

S tímto nastavením je nyní aplikace připravena k přístupu k rozhraním API pro předání rozhraní.With these settings in place, the application is now ready to access the Handoff Framework APIs. Podrobné informace o zřizování najdete v našich zřizováních zařízení a zřizování vašich průvodců aplikací.For detailed information on provisioning, please see our Device Provisioning and Provisioning Your App guides.

Implementace předáníImplementing Handoff

Aktivity uživatelů můžou pokračovat mezi aplikacemi, které jsou podepsané stejným vývojářským ID týmu a podporují stejný typ aktivity.User activities can be continued among apps that are signed with the same developer Team ID and support the same Activity Type. Implementace převzetí do aplikace Xamarin. iOS vyžaduje vytvoření objektu aktivity uživatele (v UIKit nebo AppKit ), aktualizaci stavu objektu pro sledování aktivity a pokračování aktivity na přijímajícím zařízení.Implementing Handoff in a Xamarin.iOS app requires you to create a User Activity Object (either in UIKit or AppKit), update the object's state to track the activity, and continuing the activity on a receiving device.

Identifikace aktivit uživatelůIdentifying User Activities

Prvním krokem při implementaci přeložení je určit typy aktivit uživatelů, které vaše aplikace podporuje, a zjistit, které z těchto aktivit jsou dobrými kandidáty na pokračování na jiném zařízení.The first step in implementing Handoff is to identify the types of user activities that your app supports, and seeing which of those activities are good candidates for continuation on another device. Například: aplikace ToDo může podporovat úpravu položek jako jeden _typ aktivity uživatele_a podpora procházení seznamu položek k dispozici jako jiné.For example: a ToDo app might support editing items as one User Activity Type, and support browsing the available items list as another.

Aplikace může vytvořit tolik typů aktivit uživatelů, kolik je potřeba, jednu pro jakoukoliv funkci, kterou aplikace poskytuje.An app can create as many User Activity Types as are required, one for any function that the app provides. Pro každý typ aktivity uživatele bude aplikace muset sledovat, kdy aktivita typu začíná a končí, a musí udržovat aktuální informace o stavu, aby bylo možné pokračovat v provádění této úlohy na jiném zařízení.For each User Activity Type, the app will need to track when an activity of the type begins and ends, and need to maintain up-to-date state information to continue that task on another device.

Aktivity uživatelů mohou pokračovat na libovolné aplikaci podepsané se stejným ID týmu bez jakéhokoli mapování 1:1 mezi odesílajícím a přijímajícím aplikacím.User Activities can be continued on any app signed with the same Team ID without any one-to-one mapping between the sending and receiving apps. Například daná aplikace může vytvořit čtyři různé typy aktivit, které jsou spotřebovány různými aplikacemi na jiném zařízení.For example, a given app can create four different types of activities, that are consumed by different, individual apps on another device. Jedná se o běžný výskyt mezi verzí Mac aplikace (který může mít mnoho funkcí a funkcí) a aplikací pro iOS, kde je každá aplikace menší a zaměřená na konkrétní úkol.This is a common occurrence between a Mac version of the app (that might have many features and functions) and iOS apps, where each app is smaller and focused on a specific task.

Vytváření identifikátorů typu aktivityCreating Activity Type Identifiers

Identifikátor typu aktivity je krátký řetězec přidaný do NSUserActivityTypes pole souboru info. plist aplikace, který slouží k jednoznačné identifikaci daného typu aktivity uživatele.The Activity Type Identifier is a short string added to the NSUserActivityTypes array of the app's Info.plist file used to uniquely identify a given User Activity Type. V poli bude jedna položka pro každou aktivitu, kterou aplikace podporuje.There will be one entry in the array for each activity that the app supports. Společnost Apple navrhuje pro identifikátor typu aktivity pomocí zápisu ve stylu reverzního DNS, aby se předešlo kolizím.Apple suggests using a reverse-DNS-style notation for the Activity Type Identifier to avoid collisions. Například: com.company-name.appname.activity pro konkrétní aktivity založené na aplikaci nebo com.company-name.activity pro aktivity, které mohou běžet napříč více aplikacemi.For example: com.company-name.appname.activity for specific app based activities or com.company-name.activity for activities that can run across multiple apps.

Identifikátor typu aktivity se používá při vytváření NSUserActivity instance k identifikaci typu aktivity.The Activity Type Identifier is used when creating a NSUserActivity instance to identify the type of activity. Když aktivita pokračuje na jiném zařízení, typ aktivity (společně s ID týmu aplikace) určí, která aplikace se má spustit, aby pokračovala v aktivitě.When an activity is continued on another device, the Activity Type (along with the app’s Team ID) determines which app to launch to continue the activity.

Jako příklad si vytvoříme ukázkovou aplikaci s názvem MonkeyBrowser (Stáhnout sem).As an example, we are going to create a sample app called MonkeyBrowser (download here). Tato aplikace bude prezentovat čtyři karty, každá s jinou adresou URL otevřenou v zobrazení webového prohlížeče.This app will present four tabs, each with a different URL open in a web browser view. Uživatel bude moct pokračovat na jakékoli kartě na jiném zařízení s iOS, na kterém je spuštěná aplikace.The user will be able to continue any tab on a different iOS device running the app.

Chcete-li vytvořit požadované identifikátory typu aktivity pro podporu tohoto chování, upravte soubor info. plist a přepněte do zobrazení zdroje .To create the required Activity Type Identifiers to support this behavior, edit the Info.plist file and switch to the Source view. Přidejte NSUserActivityTypes klíč a vytvořte následující identifikátory:Add a NSUserActivityTypes key and create the following identifiers:

Klíč NSUserActivityTypes a požadované identifikátory v editoru plistThe NSUserActivityTypes key and required identifiers in the plist editor

Vytvořili jsme čtyři identifikátory typu nové aktivity, jednu pro každou kartu v ukázkové aplikaci MonkeyBrowser .We created four new Activity Type Identifiers, one for each of the tabs in the example MonkeyBrowser app. Když vytváříte vlastní aplikace, nahraďte obsah NSUserActivityTypes pole identifikátory typu aktivity, které jsou specifické pro aktivity, které vaše aplikace podporuje.When creating your own apps, replace the contents of the NSUserActivityTypes array with the Activity Type Identifiers specific to the activities your app supports.

Sledování změn aktivit uživatelůTracking User Activity Changes

Když vytvoříme novou instanci NSUserActivity třídy, určíme NSUserActivityDelegate instanci, která bude sledovat změny stavu aktivity.When we create a new instance of the NSUserActivity class, we will specify a NSUserActivityDelegate instance to track changes to the activity's state. Například kód následného kódu lze použít ke sledování změn stavu:For example, the follow code can be used to track state changes:

using System;
using CoreGraphics;
using Foundation;
using UIKit;

namespace MonkeyBrowse
{
    public class UserActivityDelegate : NSUserActivityDelegate
    {
        #region Constructors
        public UserActivityDelegate ()
        {
        }
        #endregion

        #region Override Methods
        public override void UserActivityReceivedData (NSUserActivity userActivity, NSInputStream inputStream, NSOutputStream outputStream)
        {
            // Log
            Console.WriteLine ("User Activity Received Data: {0}", userActivity.Title);
        }

        public override void UserActivityWasContinued (NSUserActivity userActivity)
        {
            Console.WriteLine ("User Activity Was Continued: {0}", userActivity.Title);
        }

        public override void UserActivityWillSave (NSUserActivity userActivity)
        {
            Console.WriteLine ("User Activity will be Saved: {0}", userActivity.Title);
        }
        #endregion
    }
}

UserActivityReceivedDataMetoda je volána, když datový proud pokračování přijal data z odesílajícího zařízení.The UserActivityReceivedData method is called when a Continuation Stream has received data from a sending device. Další informace najdete níže v části podporované streamy pro pokračování .For more information, see the Supporting Continuation Streams section below.

Tato UserActivityWasContinued metoda se volá, když se v rámci aktivity z aktuálního zařízení převezme jiné zařízení.The UserActivityWasContinued method is called when another device has taken over an activity from the current device. V závislosti na typu aktivity, například přidání nové položky do seznamu úkolů, může aplikace tuto činnost na odesílajícím zařízení přerušit.Depending on the type of activity, like adding a new item to a ToDo list, the app might need abort the activity on the sending device.

UserActivityWillSaveMetoda je volána před tím, než se všechny změny aktivity uloží a synchronizují napříč místně dostupnými zařízeními.The UserActivityWillSave method is called before any changes to the activity are saved and synced across locally available devices. Tuto metodu lze použít k provedení všech posledních minut změn UserInfo vlastnosti NSUserActivity instance před jejich odesláním.You can use this method to make any last minute changes to the UserInfo property of the NSUserActivity instance before it is sent.

Vytvoření instance NSUserActivityCreating a NSUserActivity Instance

Každá aktivita, kterou si vaše aplikace chce poskytnout možnost pokračovat na jiném zařízení, musí být zapouzdřovaná v NSUserActivity instanci.Each activity that your app wishes to provide the possibility of continuing on another device must be encapsulated in a NSUserActivity instance. Aplikace může vytvořit tolik aktivit podle potřeby a povaha těchto aktivit závisí na funkcích a funkcích příslušné aplikace.The app can create as many activities as required and the nature of those activities is dependent on the functionality and features of the app in question. Například e-mailová aplikace může vytvořit jednu aktivitu pro vytvoření nové zprávy a druhou pro čtení zprávy.For example, an email app might create one activity for creating a new message, and another for reading a message.

Pro naši ukázkovou aplikaci se vytvoří nová aplikace NSUserActivity pokaždé, když uživatel zadá novou adresu URL v jednom ze zobrazení webového prohlížeče s kartami.For our example app, a new NSUserActivity is created every time the user enters a new URL in one of the tabbed web browser view. Následující kód ukládá stav dané karty:The following code stores the state of a given tab:

public NSString UserActivityTab1 = new NSString ("com.xamarin.monkeybrowser.tab1");
public NSUserActivity UserActivity { get; set; }
...

UserActivity = new NSUserActivity (UserActivityTab1);
UserActivity.Title = "Weather Tab";
UserActivity.Delegate = new UserActivityDelegate ();

// Update the activity when the tab's URL changes
var userInfo = new NSMutableDictionary ();
userInfo.Add (new NSString ("Url"), new NSString (url));
UserActivity.AddUserInfoEntries (userInfo);

// Inform Activity that it has been updated
UserActivity.BecomeCurrent ();

Vytvoří nový NSUserActivity pomocí jednoho z typů aktivity uživatele vytvořeného výše a poskytuje pro aktivitu čitelný název pro člověka.It creates a new NSUserActivity using one of the User Activity Type created above and provides a human-readable title for the Activity. Připojí se k instanci NSUserActivityDelegate vytvořené výše a sledujte změny stavu a informují iOS, že tato aktivita uživatele je aktuální aktivitou.It attaches to an instance of the NSUserActivityDelegate created above to watch for state changes and informs iOS that this User Activity is the Current Activity.

Naplnění slovníku UserInfoPopulating the UserInfo Dictionary

Jak jsme viděli výše, UserInfo vlastnost NSUserActivity třídy je NSDictionary dvojice klíč-hodnota, která slouží k definování stavu dané aktivity.As we have seen above, the UserInfo property of the NSUserActivity class is a NSDictionary of key-value pairs used to define the state of a given activity. Hodnoty uložené v UserInfo musí být jeden z následujících typů: NSArray , NSData , NSDate , NSDictionary , NSNull , NSNumber , NSSet , NSString nebo NSURL .The values stored in UserInfo must be one of the following types: NSArray, NSData, NSDate, NSDictionary, NSNull, NSNumber, NSSet, NSString, or NSURL. NSURL hodnoty dat, které odkazují na dokumenty iCloud, se automaticky upraví tak, aby odkazovaly na stejné dokumenty na přijímajícím zařízení.NSURL data values that point to iCloud documents will automatically be adjusted so that they point to the same documents on a receiving device.

V předchozím příkladu jsme vytvořili objekt a naplnili NSMutableDictionary ho pomocí jediného klíče, který poskytuje adresu URL, kterou uživatel aktuálně prohlížel na dané kartě. AddUserInfoEntries Metoda aktivity uživatele se použila k aktualizaci aktivity daty, která se použije k obnovení aktivity na přijímacím zařízení:In the example above, we created a NSMutableDictionary object and populated it with a single key providing URL that the user was currently viewing on the given tab. The AddUserInfoEntries method of the User Activity was used to update the activity with the data that will be used to restore the activity on the receiving device:

// Update the activity when the tab's URL changes
var userInfo = new NSMutableDictionary ();
userInfo.Add (new NSString ("Url"), new NSString (url));
UserActivity.AddUserInfoEntries (userInfo);

Apple navrhne zachování informací odesílaných do barest minima, aby se zajistilo, že se aktivita pošle na přijímací zařízení včas.Apple suggest keeping the information sent to the barest minimum to ensure that the activity is sent in a timely fashion to the receiving device. Pokud je třeba zadat větší informace, například je nutné odeslat obrázek připojený k dokumentu, měli byste použít proudy pokračování.If larger information is required, like an image attached to a document be edited needs to be sent, the you should use Continuation Streams. Další podrobnosti najdete v části podporované streamy pokračování .See the Supporting Continuation Streams section below for more details.

Pokračování aktivityContinuing an Activity

Při předání se automaticky informují místní zařízení s iOS a OS X, která jsou ve fyzické blízkosti původního zařízení, a přihlásí se ke stejnému účtu iCloud, aby bylo možné zajistit kontinuitu aktivit uživatelů.Handoff will automatically inform local iOS and OS X devices that are in physical proximity to the originating device and signed into the same iCloud account, of the availability of continuable User Activities. Pokud se uživatel rozhodne pokračovat v aktivitě na novém zařízení, spustí systém příslušnou aplikaci (na základě ID týmu a typu aktivity) a informace o AppDelegate tom, ke kterému pokračování musí dojít.If the user chooses to continue an activity on a new device, the system will launch the appropriate app (based on the Team ID and Activity Type) and information its AppDelegate that continuation needs to occur.

Nejprve WillContinueUserActivityWithType je volána metoda, takže aplikace může uživatele informovat o zahájení pokračování.First, the WillContinueUserActivityWithType method is called so the app can inform the user that the continuation is about to begin. Následující kód používáme v souboru AppDelegate.cs naší ukázkové aplikace pro zpracování pokračování od:We use the following code in the AppDelegate.cs file of our example app to handle a continuation starting:

public NSString UserActivityTab1 = new NSString ("com.xamarin.monkeybrowser.tab1");
public NSString UserActivityTab2 = new NSString ("com.xamarin.monkeybrowser.tab2");
public NSString UserActivityTab3 = new NSString ("com.xamarin.monkeybrowser.tab3");
public NSString UserActivityTab4 = new NSString ("com.xamarin.monkeybrowser.tab4");
...

public FirstViewController Tab1 { get; set; }
public SecondViewController Tab2 { get; set;}
public ThirdViewController Tab3 { get; set; }
public FourthViewController Tab4 { get; set; }
...

public override bool WillContinueUserActivity (UIApplication application, string userActivityType)
{
    // Report Activity
    Console.WriteLine ("Will Continue Activity: {0}", userActivityType);

    // Take action based on the user activity type
    switch (userActivityType) {
    case "com.xamarin.monkeybrowser.tab1":
        // Inform view that it's going to be modified
        Tab1.PreparingToHandoff ();
        break;
    case "com.xamarin.monkeybrowser.tab2":
        // Inform view that it's going to be modified
        Tab2.PreparingToHandoff ();
        break;
    case "com.xamarin.monkeybrowser.tab3":
        // Inform view that it's going to be modified
        Tab3.PreparingToHandoff ();
        break;
    case "com.xamarin.monkeybrowser.tab4":
        // Inform view that it's going to be modified
        Tab4.PreparingToHandoff ();
        break;
    }

    // Inform system we handled this
    return true;
}

Ve výše uvedeném příkladu každý kontroler zobrazení se registruje s AppDelegate a má veřejnou PreparingToHandoff metodu, která zobrazuje indikátor aktivity a zprávu, která uživateli informuje, že se chystá přesměrovat aktivitu na aktuální zařízení.In the above example, each View Controller registers with the AppDelegate and has a public PreparingToHandoff method that displays an Activity Indicator and a message letting the user know that the activity is about to be handed off to the current device. Příklad:Example:

private void ShowBusy(string reason) {

    // Display reason
    BusyText.Text = reason;

    //Define Animation
    UIView.BeginAnimations("Show");
    UIView.SetAnimationDuration(1.0f);

    Handoff.Alpha = 0.5f;

    //Execute Animation
    UIView.CommitAnimations();
}
...

public void PreparingToHandoff() {
    // Inform caller
    ShowBusy ("Continuing Activity...");
}

ContinueUserActivity AppDelegate Bude volána metoda z, která bude ve skutečnosti pokračovat v dané aktivitě.The ContinueUserActivity of the AppDelegate will be called to actually continue the given activity. Znovu z naší ukázkové aplikace:Again, from our example app:

public override bool ContinueUserActivity (UIApplication application, NSUserActivity userActivity, UIApplicationRestorationHandler completionHandler)
{

    // Report Activity
    Console.WriteLine ("Continuing User Activity: {0}", userActivity.ToString());

    // Get input and output streams from the Activity
    userActivity.GetContinuationStreams ((NSInputStream arg1, NSOutputStream arg2, NSError arg3) => {
        // Send required data via the streams
        // ...
    });

    // Take action based on the Activity type
    switch (userActivity.ActivityType) {
    case "com.xamarin.monkeybrowser.tab1":
        // Preform handoff
        Tab1.PerformHandoff (userActivity);
        completionHandler (new NSObject[]{Tab1});
        break;
    case "com.xamarin.monkeybrowser.tab2":
        // Preform handoff
        Tab2.PerformHandoff (userActivity);
        completionHandler (new NSObject[]{Tab2});
        break;
    case "com.xamarin.monkeybrowser.tab3":
        // Preform handoff
        Tab3.PerformHandoff (userActivity);
        completionHandler (new NSObject[]{Tab3});
        break;
    case "com.xamarin.monkeybrowser.tab4":
        // Preform handoff
        Tab4.PerformHandoff (userActivity);
        completionHandler (new NSObject[]{Tab4});
        break;
    }

    // Inform system we handled this
    return true;
}

Metoda Public PerformHandoff každého kontroleru zobrazení ve skutečnosti předchází předání a obnoví aktivitu na aktuálním zařízení.The public PerformHandoff method of each View Controller actually preforms the handoff and restores the activity on the current device. V případě příkladu se na dané kartě zobrazí stejná adresa URL, kterou uživatel prochází na jiném zařízení.In the case of the example, it displays the same URL in a given tab that the user was browsing on a different device. Příklad:Example:

private void HideBusy() {

    //Define Animation
    UIView.BeginAnimations("Hide");
    UIView.SetAnimationDuration(1.0f);

    Handoff.Alpha = 0f;

    //Execute Animation
    UIView.CommitAnimations();
}
...

public void PerformHandoff(NSUserActivity activity) {

    // Hide busy indicator
    HideBusy ();

    // Extract URL from dictionary
    var url = activity.UserInfo ["Url"].ToString ();

    // Display value
    URL.Text = url;

    // Display the give webpage
    WebView.LoadRequest(new NSUrlRequest(NSUrl.FromString(url)));

    // Save activity
    UserActivity = activity;
    UserActivity.BecomeCurrent ();

}

ContinueUserActivityMetoda zahrnuje UIApplicationRestorationHandler , který můžete volat pro obnovení aktivity na základě dokumentu nebo respondéru.The ContinueUserActivity method includes a UIApplicationRestorationHandler that you can call for document or responder based activity resuming. Při volání budete muset předat NSArray objekt nebo obnovitelné do obslužné rutiny pro obnovení.You'll need to pass a NSArray or restorable objects to the Restoration Handler when called. Příklad:For example:

completionHandler (new NSObject[]{Tab4});

Pro každý předaný objekt RestoreUserActivityState bude volána jeho metoda.For each object passed, its RestoreUserActivityState method will be called. Každý objekt pak může použít data ve UserInfo slovníku k obnovení vlastního stavu.Each object can then use the data in the UserInfo dictionary to restore its own state. Příklad:For example:

public override void RestoreUserActivityState (NSUserActivity activity)
{
    base.RestoreUserActivityState (activity);

    // Log activity
    Console.WriteLine ("Restoring Activity {0}", activity.Title);
}

Pro aplikace založené na dokumentech, pokud neimplementujete ContinueUserActivity metodu, nebo ji vrátí false UIKit nebo AppKit může automaticky obnovit aktivitu.For document-based apps, if you do not implement the ContinueUserActivity method or it returns false, UIKit or AppKit can automatically resume the activity. Další informace najdete v části Podpora odhlašování v aplikacích založených na dokumentech níže.See the Supporting Handoff in Document-Based Apps section below for more information.

Řádně se nezdařila předáníFailing Handoff Gracefully

Vzhledem k tomu, že předání spoléhá na přenos informací mezi kolekcí volně připojených zařízení s iOS a OS X, může proces přenosu někdy selhat.Since Handoff relies on the transmission of information between a collection loosely connected iOS and OS X devices, the transfer process can sometimes fail. Měli byste navrhnout aplikaci tak, aby tyto chyby řádně zpracovala a informovala uživatele o všech situacích, které vznikají.You should design your app to handle these failures gracefully and inform the user of any situations that arise.

V případě selhání bude DidFailToContinueUserActivitiy AppDelegate volána metoda.In the event of a failure, the DidFailToContinueUserActivitiy method of the AppDelegate will be called. Příklad:For example:

public override void DidFailToContinueUserActivitiy (UIApplication application, string userActivityType, NSError error)
{
    // Log information about the failure
    Console.WriteLine ("User Activity {0} failed to continue. Error: {1}", userActivityType, error.LocalizedDescription);
}

K poskytnutí informací o selhání byste měli použít poskytnutý NSError uživatel.You should use the supplied NSError to provide information to the user about the failure.

Přeložení nativní aplikace na webový prohlížečNative App to Web Browser Handoff

Uživatel může pokračovat v aktivitě, aniž by byla na požadovaném zařízení nainstalovaná příslušná nativní aplikace.A user may want to continue an activity without having an appropriate native app installed on the desired device. V některých situacích může webové rozhraní poskytovat požadovanou funkci a aktivita může stále pokračovat.In some situations, a web based interface may provide the required functionality and the activity can still be continued. Například e-mailový účet uživatele může poskytovat webové uživatelské rozhraní pro vytváření a čtení zpráv.For example, the user's email account may provide a web-base UI for composing and reading messages.

Pokud původní, nativní aplikace zná adresu URL webového rozhraní (a požadovaná syntaxe pro identifikaci dané položky pokračuje), může tyto informace kódovat ve WebpageURL vlastnosti NSUserActivity instance.If the originating, native app knows the URL for the web interface (and the required syntax for identifying the given item being continued), it can encode this information in the WebpageURL property of the NSUserActivity instance. Pokud pro přijímací zařízení není nainstalovaná příslušná nativní aplikace pro zpracování pokračování, může se zavolat poskytnuté webové rozhraní.If the receiving device doesn't have an appropriate native app installed to handle the continuation, the provided web interface can be called.

Webový prohlížeč pro předání nativní aplikaceWeb Browser to Native App Handoff

Pokud uživatel používal webové rozhraní na zdrojovém zařízení a nativní aplikace na přijímacím zařízení bude přihlášena k doméně této WebpageURL vlastnosti, pak systém použije tuto aplikaci, aby zpracovala pokračování.If the user was using a web-based interface on the originating device, and a native app on the receiving device claims the domain portion of the WebpageURL property, then the system will use that app the handle the continuation. Nové zařízení dostane NSUserActivity instanci, která označuje typ aktivity, BrowsingWeb a WebpageURL bude obsahovat adresu URL, na kterou uživatel navštívil, UserInfo slovník bude prázdný.The new device will receive a NSUserActivity instance that marks the Activity Type as BrowsingWeb and the WebpageURL will contain the URL the user was visiting, the UserInfo dictionary will be empty.

Aby se aplikace účastnila tohoto typu předání, musí tuto doménu uplatnit v com.apple.developer.associated-domains nároku ve formátu <service>:<fully qualified domain name> (například: activity continuation:company.com ).For an app to participate in this type of Handoff, it must claim the domain in a com.apple.developer.associated-domains entitlement with the format <service>:<fully qualified domain name> (for example: activity continuation:company.com).

Pokud zadaná doména odpovídá WebpageURL hodnotě vlastnosti, přepošle se na web v této doméně seznam schválených ID aplikací.If the specified domain matches a WebpageURL property's value, Handoff downloads a list of approved app IDs from the website at that domain. Web musí obsahovat seznam schválených ID v podepsaném souboru JSON s názvem Apple-App-site-Association (například https://company.com/apple-app-site-association ).The website must provide a list of approved IDs in a signed JSON file named apple-app-site-association (for example, https://company.com/apple-app-site-association).

Tento soubor JSON obsahuje slovník, který určuje seznam ID aplikací ve formuláři <team identifier>.<bundle identifier> .This JSON file contains a dictionary that specifies a list of app IDs in the form <team identifier>.<bundle identifier>. Příklad:For example:

{
    "activitycontinuation": {
        "apps": [    "YWBN8XTPBJ.com.company.FirstApp",
            "YWBN8XTPBJ.com.company.SecondApp" ]
    }
}

Pokud chcete soubor JSON podepsat (takže má správnou hodnotu Content-Type application/pkcs7-mime ), použijte aplikaci Terminal a openssl příkaz s certifikátem a klíčem vydaným certifikační autoritou, která je důvěryhodná pro iOS (viz https://support.apple.com/kb/ht5012 pro seznam).To sign the JSON file (so that it has the correct Content-Type of application/pkcs7-mime), use the Terminal app and a openssl command with a certificate and key issued by a certificate authority trusted by iOS (see https://support.apple.com/kb/ht5012 for a list). Příklad:For example:

echo '{"activitycontinuation":{"apps":["YWBN8XTPBJ.com.company.FirstApp",
"YWBN8XTPBJ.com.company.SecondApp"]}}' > json.txt

cat json.txt | openssl smime -sign -inkey company.com.key
-signer company.com.pem
-certfile intermediate.pem
-noattr -nodetach
-outform DER > apple-app-site-association

opensslPříkaz vypíše podepsaný soubor JSON, který umístíte na svůj web, na adrese URL společnosti Apple-App-site-Association .The openssl command outputs a signed JSON file that you place on your website at the apple-app-site-association URL. Příklad:For example:

https://example.com/apple-app-site-association.

Aplikace získá všechny aktivity, jejichž WebpageURL doména má své com.apple.developer.associated-domains nároky.The app will receive any activity whose WebpageURL domain is in its com.apple.developer.associated-domains entitlement. Pouze http protokoly a https jsou podporovány, jakýkoli jiný protokol vyvolá výjimku.Only the http and https protocols are support, any other protocol will raise an exception.

Podpora předání v aplikacích založených na dokumentechSupporting Handoff in Document-Based Apps

Jak je uvedeno výše, v systémech iOS a OS X budou aplikace založené na dokumentech automaticky podporovat předání dokumentů založených na iCloud, pokud soubor info. plist aplikace obsahuje CFBundleDocumentTypes klíč NSUbiquitousDocumentUserActivityType .As stated above, on iOS and OS X, document-based apps will automatically support Handoff of iCloud-based documents if the app’s Info.plist file contains a CFBundleDocumentTypes key of NSUbiquitousDocumentUserActivityType. Příklad:For example:

<key>CFBundleDocumentTypes</key>
<array>
    <dict>
        <key>CFBundleTypeName</key>
        <string>NSRTFDPboardType</string>
        . . .
        <key>LSItemContentTypes</key>
        <array>
        <string>com.myCompany.rtfd</string>
        </array>
        . . .
        <key>NSUbiquitousDocumentUserActivityType</key>
        <string>com.myCompany.myEditor.editing</string>
    </dict>
</array>

V tomto příkladu je řetězec označení aplikace reverzních DNS s názvem připojené aktivity.In this example the string is a reverse-DNS app designator with the name of the activity appended. Pokud tento parametr zadáte, položky typu aktivity není nutné opakovat v poli NSUserActivityTypes souboru info. plist .If entered this way, the activity type entries do not need to be repeated in the NSUserActivityTypes array of the Info.plist file.

Automaticky vytvořený objekt aktivity uživatele (dostupný prostřednictvím UserActivity Vlastnosti dokumentu) může odkazovat jiné objekty v aplikaci a použít k obnovení stavu při pokračování.The automatically-created User Activity object (available through the document’s UserActivity property) can be referenced by other objects in the app and used to restore state on continuation. Například pro sledování výběru položek a umístění dokumentu.For example, to track item selection and document position. Tuto vlastnost aktivity je nutné nastavit NeedsSave na hodnotu true pokaždé, když se stav změní a aktualizuje UserInfo slovník v UpdateUserActivityState metodě.You need to set this activities NeedsSave property to true whenever the state changes and update the UserInfo dictionary in the UpdateUserActivityState method.

UserActivityVlastnost lze použít z libovolného vlákna a odpovídá protokolu KVO (Key-Value pozorovatele), takže jej lze použít k uchování dokumentu v synchronizaci při jeho přesunu do nebo z iCloud.The UserActivity property can be used from any thread and conforms to the key-value observing (KVO) protocol, so it can be used to keep a document in sync as it moves in and out of iCloud. UserActivityPři zavření dokumentu bude vlastnost zrušena.The UserActivity property will be invalidated when the document is closed.

Další informace najdete v tématu Podpora aktivit uživatelů společnosti Apple v dokumentaci k dokumentovým aplikacím .For more information, please see Apple’s User Activity Support in Document-Based Apps documentation.

Podpora předání v případě reakcíSupporting Handoff in Responders

Nastavením vlastností můžete přidružit k aktivitám reakce (zděděné z UIResponder systému iOS nebo NSResponder v OS X) na aktivity UserActivity .You can associate responders (inherited from either UIResponder on iOS or NSResponder on OS X) to activities by setting their UserActivity properties. Systém automaticky uloží UserActivity vlastnost ve vhodných časech voláním UpdateUserActivityState metody Responder pro přidání aktuálních dat do objektu aktivity uživatele pomocí AddUserInfoEntriesFromDictionary metody.The system automatically saves the UserActivity property at the appropriate times, calling the responder’s UpdateUserActivityState method to add current data to the User Activity object using the AddUserInfoEntriesFromDictionary method.

Podpora streamování pokračováníSupporting Continuation Streams

Může se jednat o situace, kdy množství informací potřebných k pokračování aktivity nelze efektivně přenést počáteční datovou část předání.The might be situations where the amount of information required to continue an activity cannot be efficiently transferred by the initial Handoff payload. V těchto situacích může přijímající aplikace vytvořit jeden nebo více datových proudů mezi sebou samými a původní aplikací pro přenos dat.In these situations, the receiving app can establish one or more stream between itself and the originating app to transfer the data.

Původní aplikace nastaví SupportsContinuationStreams vlastnost NSUserActivity instance na true .The originating app will set the SupportsContinuationStreams property of the NSUserActivity instance to true. Příklad:For example:

// Create a new user Activity to support this tab
UserActivity = new NSUserActivity (ThisApp.UserActivityTab1){
    Title = "Weather Tab",
    SupportsContinuationStreams = true
};
UserActivity.Delegate = new UserActivityDelegate ();

// Update the activity when the tab's URL changes
var userInfo = new NSMutableDictionary ();
userInfo.Add (new NSString ("Url"), new NSString (url));
UserActivity.AddUserInfoEntries (userInfo);

// Inform Activity that it has been updated
UserActivity.BecomeCurrent ();

Přijímající aplikace potom může volat GetContinuationStreams metodu NSUserActivity v jejím rámci AppDelegate k vytvoření datového proudu.The receiving app can then call the GetContinuationStreams method of the NSUserActivity in its AppDelegate to establish the stream. Příklad:For example:

public override bool ContinueUserActivity (UIApplication application, NSUserActivity userActivity, UIApplicationRestorationHandler completionHandler)
{

    // Report Activity
    Console.WriteLine ("Continuing User Activity: {0}", userActivity.ToString());

    // Get input and output streams from the Activity
    userActivity.GetContinuationStreams ((NSInputStream arg1, NSOutputStream arg2, NSError arg3) => {
        // Send required data via the streams
        // ...
    });

    // Take action based on the Activity type
    switch (userActivity.ActivityType) {
    case "com.xamarin.monkeybrowser.tab1":
        // Preform handoff
        Tab1.PerformHandoff (userActivity);
        completionHandler (new NSObject[]{Tab1});
        break;
    case "com.xamarin.monkeybrowser.tab2":
        // Preform handoff
        Tab2.PerformHandoff (userActivity);
        completionHandler (new NSObject[]{Tab2});
        break;
    case "com.xamarin.monkeybrowser.tab3":
        // Preform handoff
        Tab3.PerformHandoff (userActivity);
        completionHandler (new NSObject[]{Tab3});
        break;
    case "com.xamarin.monkeybrowser.tab4":
        // Preform handoff
        Tab4.PerformHandoff (userActivity);
        completionHandler (new NSObject[]{Tab4});
        break;
    }

    // Inform system we handled this
    return true;
}

Na zdrojovém zařízení delegát aktivity uživatele obdrží Stream voláním DidReceiveInputStream metody, aby poskytovala data požadovaná k pokračování aktivity uživatele při obnovení zařízení.On the originating device, the User Activity Delegate receives the streams by calling its DidReceiveInputStream method to provide the data requested to continue the user activity on the resuming device.

Použijete NSInputStream k poskytnutí přístupu k datovým proudům, které jsou jen pro čtení, a k NSOutputStream poskytnutí přístupu jen pro zápis.You will use a NSInputStream to provide read-only access to stream data, and a NSOutputStream provide write-only access. Datové proudy by měly být použity v žádosti a odpovědi, kde přijímající aplikace požaduje více dat a původní aplikace je poskytuje.The streams should be used in a request and response fashion, where the receiving app requests more data and the originating app provides it. To znamená, že data zapsaná do výstupního datového proudu na zdrojovém zařízení jsou čtena ze vstupního datového proudu na pokračování zařízení a naopak.So that, data written to the output stream on the originating device is read from the input stream on the continuing device, and vice versa.

Dokonce i v situacích, kdy jsou vyžadovány požadavky na pokračování, musí existovat minimální komunikace mezi těmito dvěma aplikacemi.Even in situations where Continuation Stream are required, there should be a minimal of back and forth communication between the two apps.

Další informace najdete v dokumentaci k používání proudů pro pokračování .For more information, see Apple’s Using Continuation Streams documentation.

Předání osvědčených postupůHandoff Best Practices

Úspěšná implementace bezproblémového pokračování aktivity uživatele prostřednictvím předání vyžaduje pečlivou návrh z důvodu všech různých součástí.The successful implementation of the seamless continuation of a User Activity via Handoff requires careful design because of all the various components involved. Společnost Apple navrhuje přijmout osvědčené postupy pro vaše aplikace s podporou předávaných aplikací:Apple suggests adopting the follow best practices for your Handoff enabled apps:

  • Navrhněte své uživatelské aktivity tak, aby vyžadovaly nejmenší možnou datovou část, aby se mohla spojit stav aktivity, která bude pokračovat.Design your User Activities to require the smallest payload possible to relate the state of the activity to be continued. Čím větší je datová část, tím déle trvá spuštění pokračování.The larger the payload, the longer it takes the continuation to start.
  • Pokud pro úspěšné pokračování potřebujete přenášet velké objemy dat, vezměte v úvahu náklady spojené s konfigurací a zatížením sítě.If you must transfer large amounts of data for successful continuation, take into account the costs involved in configuration and network overhead.
  • Pro velkou aplikaci pro Mac je běžné vytvářet aktivity uživatelů, které jsou na zařízeních s iOS zpracovávány na několika menších aplikacích specifických pro konkrétní úkoly.It is common for a large Mac app to create User Activities that are handled by several, smaller, task-specific apps on iOS devices. Různé aplikace a verze operačního systému by měly být navržené tak, aby dobře spolupracovaly nebo nefungovaly správně.The different app and OS versions should be designed to work well together or fail gracefully.
  • Při zadávání typů aktivit použijte zpětný zápis DNS, abyste zabránili kolizím.When specifying your Activity Types, use reverse-DNS notation to avoid collisions. Pokud je aktivita specifická pro danou aplikaci, její název by měl být zahrnut do definice typu (například com.myCompany.myEditor.editing ).If an activity is specific to a given app, its name should be included in the type definition (for example com.myCompany.myEditor.editing). Pokud aktivita může fungovat napříč více aplikacemi, vyřaďte název aplikace z definice (například com.myCompany.editing ).If the activity can work across multiple apps, drop the app name from the definition (for example com.myCompany.editing).
  • Pokud vaše aplikace potřebuje aktualizovat stav aktivity uživatele ( NSUserActivity ), nastavte NeedsSave vlastnost na hodnotu true .If your app needs to update the state of a User Activity (NSUserActivity) set the NeedsSave property to true. V příslušných časech předáte volání metody delegáta UserActivityWillSave , abyste mohli UserInfo slovník aktualizovat podle potřeby.At appropriate times, Handoff will call the delegate's UserActivityWillSave method so you can update the UserInfo dictionary as required.
  • Vzhledem k tomu, že proces předání se na přijímacím zařízení nemusí okamžitě inicializovat, měli byste implementovat AppDelegate WillContinueUserActivity a informovat uživatele o tom, že se chystá spuštění pokračování.Because the Handoff process might not initialize instantly on the receiving device, you should implement the AppDelegate's WillContinueUserActivity and inform the user that a continuation is about to start.

Ukázka předání aplikaceExample Handoff App

Jako příklad použití předání v aplikaci Xamarin. iOS jsme do tohoto průvodce zahrnuli ukázkovou aplikaci MonkeyBrowser .As an example of using Handoff in a Xamarin.iOS app, we have included the MonkeyBrowser sample app with this guide. Aplikace má čtyři karty, které může uživatel použít k procházení webu, každý s daným typem aktivity: počasí, oblíbené, kávové přerušení a práce.The app has four tabs that the user can use to browse the web, each with a given activity type: Weather, Favorite, Coffee Break and Work.

Pokud uživatel zadá novou adresu URL a klepne na tlačítko Přejít , vytvoří se na libovolné kartě nový, NSUserActivity který obsahuje adresu URL, kterou uživatel aktuálně prohlíží:On any tab, when the user enters a new URL and taps the Go button, a new NSUserActivity is created for that tab that contains the URL that the user is currently browsing:

Ukázka předání aplikaceExample Handoff App

Pokud je aplikace MonkeyBrowser nainstalovaná na jiném z uživatelských zařízení, je přihlášená do iCloud pomocí stejného uživatelského účtu, je ve stejné síti a v blízké blízkosti výše uvedeného zařízení se předaná aktivita zobrazí na domovské obrazovce (v levém dolním rohu):If another of the user’s devices has the MonkeyBrowser app installed, is signed into iCloud using the same user account, is on the same network and in close proximity to the above device, the Handoff Activity will be displayed on the home screen (in the lower left hand corner):

Aktivita odevzdání zobrazená na domovské obrazovce v levém dolním rohuThe Handoff Activity displayed on the home screen in the lower left hand corner

Pokud uživatel přetáhne vzhůru na ikonu pro předání, aplikace se spustí a na novém zařízení bude pokračovat aktivita uživatele zadaná v nástroji NSUserActivity :If the user drags upward on the Handoff icon, the app will be launched and the User Activity specified in the NSUserActivity will be continued on the new device:

Činnost uživatele pokračuje na novém zařízení.The User Activity continued on the new device

Když se aktivita uživatele úspěšně pošle do jiného zařízení Apple, pošle se odesílajícímu zařízení NSUserActivity volání UserActivityWasContinued metody, NSUserActivityDelegate aby vědělo, že aktivita uživatele se úspěšně přenesla na jiné zařízení.When the User Activity has been successfully sent to another Apple device, the sending device’s NSUserActivity will receive a call to the UserActivityWasContinued method on its NSUserActivityDelegate to let it know that the User Activity has been successfully transferred to another device.

ShrnutíSummary

Tento článek obsahuje úvod k rozhraní předání, které se používá k pokračování aktivity uživatele mezi více zařízeními Apple uživatele.This article has given an introduction to the Handoff framework used to continue a User Activity between multiple of the user's Apple devices. V dalším kroku se ukázalo, jak povolit a implementovat přeložení v aplikaci Xamarin. iOS.Next, it showed how to enable and implement Handoff in a Xamarin.iOS app. Nakonec popisuje různé typy dostupných pokračování a předání osvědčených postupů.Finally, it discussed the different types of Handoff continuations available and the Handoff best practices.