Share
Kijk Connectivity is een nieuw communicatieraamwerk dat is uitgebracht naast iOS 9 en watchOS 2. Het belangrijkste doel is om eenvoudig en naadloos informatie over te dragen tussen een Apple Watch-toepassing en de bijbehorende iOS-applicatie..
Het framework biedt veel verschillende functionaliteiten. Een paar weken geleden schreef Jorge Costa over de mogelijkheid om berichten te verzenden tussen een iOS- en een Apple Watch-toepassing. In deze zelfstudie zullen we inzoomen op het overbrengen van gegevens op de achtergrond.
De mogelijkheid om berichten te verzenden is ontworpen voor gegevens die onmiddellijk nodig zijn door het andere apparaat. Daarentegen zijn achtergrondoverdrachten het meest geschikt voor grotere hoeveelheden gegevens die niet onmiddellijk door de tegenpartij nodig zijn. Een uitzondering hierop is met informatie over complicaties, die we later in deze zelfstudie bespreken.
Voor deze zelfstudie is vereist dat u Xcode 7 gebruikt in OS X 10.10 of hoger. Je zult ook het startersproject van GitHub moeten downloaden.
Om het Watch Connectivity-framework te gebruiken, moeten zowel uw iOS- als watchOS-app een klasse hebben die voldoet aan de WCSessionDelegate protocol en dat de standaard correct configureert WCSession. De methoden van de WCSessionDelegate protocol verwerken het ontvangen van alle gegevens via het Watch Connectivity-framework en stellen u in staat controle te krijgen over de nieuwe gegevens in uw applicatie.
Open het startersproject in Xcode en bewerk het AppDelegate.swift. Voeg bovenaan het volgende toe importeren uitspraak:
importeer WatchConnectivity
Werk vervolgens de klassedefinitie van de bij AppDelegate klasse om het conform te maken met de WCSessionDelegate protocol.
class AppDelegate: UIResponder, UIApplicationDelegate, WCSessionDelegate
We verklaren ook een eigenschap van het type WCSession! in de AppDelegate klasse om een verwijzing naar de standaard op te slaan WCSession voorwerp.
var sessie: WCSession!
Werk ten slotte het applicatie (_: didFinishLaunchingWithOptions :) methode zoals hieronder getoond.
func applicatie (toepassing: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool session = WCSession.defaultSession () session.delegate = self if WCSession.isSupported () session.activateSession () return true
In applicatie (_: didFinishLaunchingWithOptions :), we krijgen een verwijzing naar de standaard WCSession object, stel de gedelegeerde van de sessie in op uw apps AppDelegate instantie en, indien ondersteund, activeer de sessie. De wordt ondersteund class-methodecontroles om te zien of de watchOS-app van een tegenhanger voor uw iOS-app is geïnstalleerd op een gekoppelde Apple Watch en in staat is om gegevens te verzenden.
De setup voor de watchOS-kant lijkt erg op elkaar. Open ExtensionDelegate.swift en vervang de inhoud ervan door het volgende:
import WatchKit importeren WatchConnectivity-klasse ExtensionDelegate: NSObject, WKExtensionDelegate, WCSessionDelegate var session: WCSession! func applicationDidFinishLaunching () session = WCSession.defaultSession () session.delegate = self session.activateSession () func applicationDidBecomeActive () func applicationWillResignActive ()
Je zult merken dat we niet bellen wordt ondersteund op de WCSession klas voordat de sessie wordt geactiveerd. Dit komt omdat deze methode altijd terugkeert waar aan de zijde van watchOS.
Als u wilt controleren of alles correct werkt, voert u uw Apple Watch-app uit op een van de twee simulators, zoals hieronder wordt weergegeven.
Voer vervolgens uw iOS-app uit op hetzelfde iPhone-simulatortype dat u hebt geselecteerd bij het uitvoeren van de horloge-app.
Zodra uw iOS-app is gelanceerd, moet uw Apple Watch-simulator teruggaan naar de wijzerplaat zoals wordt weergegeven in de onderstaande schermafbeelding.
Met de standaard WCSession object correct geconfigureerd, het is tijd voor ons om enkele gegevens te verzenden tussen de iOS en de Apple Watch-toepassing.
Open TableViewController.swift en voeg de volgende regel code toe aan het einde van de createNewItem (_ :) methode:
WCSession.defaultSession (). TransferUserInfo (item)
De transferUserInfo (_ :) methode accepteert een woordenboek als enige parameter. Nadat deze methode is aangeroepen, wordt het door u opgegeven gebruikersinfo-woordenboek toegevoegd aan de wachtrij met informatie die moet worden overgedragen.
Zowel iOS als watchOS werken in combinatie met elkaar om de informatie op een geschikt moment over te dragen. Het gecombineerde systeem kijkt naar zaken als app-gebruik, levensduur van de batterij, of het andere apparaat momenteel wordt gebruikt, enz. Zodra het systeem de informatie heeft overgedragen, voert de app op het andere apparaat een gedelegeerde callback-methode uit wanneer de volgende keer wordt gelanceerd.
Nu is het tijd voor ons om de ontvangstkant van de Apple Watch te implementeren. Open ExtensionDelegate.swift en voeg de volgende methode toe aan de ExtensionDelegate klasse:
Accentsconagua
func sessie (sessie: WCSession, didReceiveUserInfo userInfo: [String: AnyObject]) dispatch_async (dispatch_get_main_queue ()) () -> Void in als let items = NSUserDefaults.standardUserDefaults (). objectForKey ("items") als? [NSDictionary] var newItems = items newItems.append (userInfo) NSUserDefaults.standardUserDefaults (). SetObject (newItems als AnyObject, forKey: "items") else NSUserDefaults.standardUserDefaults (). SetObject ([userInfo] als AnyObject, forKey : "items")Deze methode wordt aangeroepen zodra we de Apple Watch-app uitvoeren en nadat de informatie is overgedragen.
Merk op dat hoewel deze tutorial alleen een voorbeeld toont van het overbrengen van informatie van iOS naar watchOS, de WCSession en WCSessionDelegate methoden gedragen zich op beide platforms precies hetzelfde voor achtergrondoverdrachten.
Met deze code geïmplementeerd, voert u uw Apple Watch-app uit in de simulator. Voer vervolgens de iPhone-app opnieuw uit en druk op de knop om een nieuw item te maken.
Ga nu terug naar de Apple Watch-simulator en druk op Command-Shift-H twee keer om terug te gaan naar de meest recente app. Je zult zien dat het item dat je zojuist hebt gemaakt, wordt weergegeven op de Apple Watch.
Merk op dat, hoewel de informatieoverdracht onmiddellijk plaatsvond tussen de simulatoren, in een situatie van de echte wereld met fysieke apparaten dit niet altijd het geval zal zijn.
Laat de Apple Watch-simulator in de menubalk staan of druk op als uw iOS-app nog steeds actief is Command-Q. Nadat u dit hebt gedaan, drukt u op de knop in uw iOS-app om nog een aantal items te maken, zoals hieronder wordt weergegeven.
Telkens wanneer u probeert informatie over te dragen met behulp van het framework Watch Connectivity, wordt het toegevoegd aan een wachtrij die geleidelijk wordt gewist wanneer informatie wordt overgedragen. Deze wachtrij is toegankelijk en ook de overschrijvingen in de wachtrij zijn toegankelijk.
Dit is handig, omdat u kunt zien hoeveel artikelen nog in behandeling zijn en u kunt zelfs specifieke overdrachten annuleren als dat nodig is. De items die u zojuist hebt gemaakt, worden momenteel vastgehouden in de gebruikersinformatiewachtrij omdat de Apple Watch momenteel is losgekoppeld van het bovenliggende apparaat, waardoor een overdracht onmogelijk is.
Open AppDelegate.swift en voeg de volgende code toe aan het eind van applicatie (_: didFinishLaunchingWithOptions :):
laat transfers = session.outstandingUserInfoTransfers if transfers.count> 0 let transfer = transfers.first! transfer.cancel ()
Met deze code hebben we toegang tot de uitstekende overdrachten van gebruikersinformatie en, als er minstens één is, annuleert u de eerste overdracht. De WCSessionUserInfoTransfer objecten terug van de outstandingUserInfoTransfers eigenschap hebben ook twee alleen-lezen eigenschappen die u kunt openen:
gebruikers informatie: Deze eigenschap slaat het woordenboek op dat u overdraagt.overbrengen: Deze eigenschap slaat een Booleaanse waarde op en geeft aan of de gebruikersinformatie momenteel wordt overgedragen.Er is niet veel functionaliteit beschikbaar met uitstekende informatieoverdracht in het kader van Watch Connectivity, maar afhankelijk van uw toepassing kunnen sommige van deze functies zeer nuttig zijn.
In deze zelfstudie hebben we alleen achtergrondoverdrachten van gebruikersinformatie behandeld, maar er zijn een paar andere manieren om gegevens tussen apparaten over te zetten. Elk van deze methoden is ontworpen voor een specifiek doel bij communicatie tussen een iPhone en een Apple Watch.
Hier moet u informatie tussen apparaten overbrengen, waarbij alleen de meest recente informatie relevant is. U zet een enkel woordenboek over door het updateApplicationContext (_: error :) methode. De fout parameter in deze methode is een verwijzing naar een NSError object, dat wordt gevuld met informatie als er een probleem optreedt met de overdracht.
Aan de ontvangende kant kunt u de sessie (_: didReceiveApplicationContext :) methode of, als alternatief, toegang tot de toepassingscontext via de standaard WCSession voorwerpen receivedApplicationContext eigendom.
Hier moet u een gebruikerswoordenboek voor één gebruiker overdragen, specifiek voor de aangepaste complicatie van uw app. Je kunt alleen informatie van de kant van iOS verzenden en dit gebeurt met de transferCurrentComplicationUserInfo (_ :) methode.
Het belangrijkste verschil tussen dit en het transferUserInfo (_ :) De methode die eerder in deze zelfstudie werd gebruikt, is dat het systeem bij het bijwerken van een complicatie altijd zal proberen de informatie onmiddellijk over te dragen.
Houd er rekening mee dat een overdracht niet wordt gegarandeerd omdat de apparaten kunnen worden losgekoppeld of uw complicatie mogelijk het budget voor de uitvoering van de achtergrond heeft overschreden. Als een overdracht van informatie over complicaties niet kan worden voltooid, wordt deze toegevoegd aan de outstandingUserInfoTransfers wachtrij waar het kan worden bekeken en geannuleerd indien nodig.
Merk ook op dat, als een complicatie-info-overdracht in de wachtrij staat en u de transferCurrentComplicationUserInfo (_ :) methode opnieuw, de bestaande overdracht in de wachtrij wordt ongeldig en geannuleerd.
U kunt zelfs het framework Watch Connectivity gebruiken om bestanden over te zetten tussen apparaten. Dit gebeurt via de transferFile (_: metaData :) methode waarbij de eerste parameter een lokale is NSURL naar het bestand en de tweede is een optioneel woordenboek, met alle aanvullende gegevens die aan dat bestand zijn gekoppeld.
Zoals je zou verwachten, wordt het ontvangen van dit bestand afgehandeld door een methode van de WCSessionDelegate protocol, de sessie (_: didReceiveFile :) methode om precies te zijn. In deze methode krijg je een single WCSessionFile object dat een nieuwe lokale URL bevat voor het daadwerkelijke bestand, evenals de metagegevens die u hebt overgebracht.
Net als bij overdrachten van gebruikersinformatie, kunt u ook lopende of bestandsoverdrachten via de standaard bekijken WCSession voorwerpen outstandingFileTransfers eigendom.
Over het algemeen biedt het Watch Connectivity-framework een zeer eenvoudige en gemakkelijk te gebruiken interface voor het overbrengen van gegevens tussen een aangesloten iPhone en een Apple Watch. Het framework maakt de overdracht mogelijk van gebruikersinformatie, applicatiecontext en informatieve woordenboeken en bestanden.
U moet nu vertrouwd zijn met zowel het verzenden als ontvangen van informatie met behulp van het Watch Connectivity-framework en ook hoe u kunt omgaan met uitstaande overdrachten.
Laat zoals altijd uw opmerkingen en feedback achter in de opmerkingen hieronder.
