Share
På WWDC 2015 annonserte Apple sin første store oppdatering til Apple Watch-programvaren, watchOS 2. Denne nye oppdateringen ga med mange nye APIer og funksjoner for utviklere å dra nytte av, inkludert innfødte apps, tilgang til flere av Apple Watch-maskinvaren og bedre kommunikasjon med den overordnede iOS-appen.
I denne opplæringen skal jeg vise deg hvordan du kan dra nytte av en annen ny funksjon, evnen til å lage tilpassede watch komplikasjoner ved hjelp av ClockKit rammeverket. Denne opplæringen krever at du kjører Xcode 7 på OS X Yosemite (10.10) eller senere.
Hvis du ikke allerede vet, er Apple Watch-komplikasjoner de små grensesnittelementene som viser informasjon på klokkeansiktet.
Skjermbildet over viser hvordan fem komplikasjoner vises på Modular se på ansiktet i tillegg til tiden i øverste høyre hjørne.
Opprett et nytt prosjekt i Xcode, ved hjelp av watchOS> Applikasjon> iOS App med WatchKit App mal.
Deretter konfigureres prosjektet som vist nedenfor, og sørg for at Inkluder komplikasjon er sjekket.
Når Xcode har opprettet prosjektet ditt, åpner du ClockKit Introduksjon WatchKit Extension i Prosjektnavigator. Du vil se en ny Komplikasjoner Konfigurasjon delen som vist nedenfor.
De fem boksene under Støttede familier Representer de forskjellige komplikasjonsfamiliene som appen støtter. I denne opplæringen skal vi fokusere på Modular Large familie. Du kan fjerne merket for de andre boksene for nå.
Som nevnt i Apples watchOS 2 Overgang Guide, Det er svært oppfordret at appen din støtter alle fem familier. Følgende bilde viser hvor disse forskjellige familier brukes.
Bilde Kreditt: Apple WatchOS 2 Overgang GuideFor å lære deg hvordan du bruker ClockKit, kommer du til å lage en enkel komplikasjon som viser tid, navn og sjanger av falske TV-programmer på en bestemt stasjon gjennom dagen.
Å begynne, åpne ComplicationController.swift i ClockKit Introduksjon WatchKit Extension mappe. Xcode har automatisk opprettet denne filen for deg. Den inneholder en ComplicationController klassen, som overholder og implementerer CLKComplicationDataSource protokollen.
Metodene knyttet til denne protokollen er hvordan du gir data til ClockKit om komplikasjonene du vil vise. Protokollens metoder inneholder en handler som du må ringe for å sende data tilbake til ClockKit.
Når du gir data til ClockKit, gjør du det i form av en tidslinje. Du gjør dette ved å fylle opp komplikasjonens tidslinje med dataobjekter som er knyttet til et bestemt tidspunkt. Disse dataobjektene er modellert av CLKComplicationTimelineEntry klasse. Når et bestemt tidspunkt er nådd, viser ClockKit automatisk det riktige innholdet for appen din.
Tidslinjepostene dine hentes og lagres av ClockKit godt før tiden de skal vises på. Dette betyr at dataene må kunne hentes og planlegges på forhånd. Hver applikasjon har et begrenset tidsbudsjett for å oppdatere innholdet i bakgrunnen. Med andre ord er komplikasjoner ikke en erstatning for push notifikasjoner eller varslingssenteret.
Den største fordelen med å levere data på denne måten er å opprettholde en utmerket brukeropplevelse. Innholdet for hver komplikasjon er umiddelbart tilgjengelig når brukeren vekker håndleddet. En av de andre fordelene ved å bruke denne tidslinjedatamodellen er muligheten til enkelt å adoptere det nye Time Travel funksjonen i watchOS 2. Dette er når brukeren slår den digitale kronen mens han ser på klokken og dataene i komplikasjonene gjenspeiler tiden som har vært reiste til.
I koden din, under Tidslinjekonfigurasjon Merk, du vil se fire metoder som kreves for å konfigurere tidslinjen. For å gjøre denne opplæringen enkel og lett å forstå, vil vi bare støtte fremover tidsreiser og gi data i opptil 24 timer. For å gjøre dette, oppdater implementeringen av de tre første metodene som vist nedenfor.
Funk getSupportedTimeTravelDirectionsForComplication (komplikasjon: CLKComplication, withHandler handler: (CLKComplicationTimeTravelDirections) -> Feid) handler (.Forward) func getTimelineStartDateForComplication (komplikasjon: CLKComplication, withHandler handler: (NSDate?) -> Feid) handler (NSDate ()) func getTimelineEndDateForComplication (komplikasjon: CLKComplication, withHandler handler: (NSDate?) -> Feid) handler (NSDate (timeIntervalSinceNow: (60 * 60 * 24))
Den fjerde metoden i Tidslinjekonfigurasjon seksjon, getPrivacyBehaviorForComplication (_: withHandler :), brukes til å angi om du vil at komplikasjonens innhold skal vises når enheten er låst eller ikke. Standardverdien gikk til handleren, ShowOnLockScreen, betyr at dataene alltid vil være synlige.
Bla til bunnen av ComplicationController klasse og finn getPlaceHolderTemplateForComplication (_: withHandler :) metode. I denne metoden lager og sender du en CLKComplicationTemplate tilbake til handleren for dataene du vil vise. I denne opplæringen skal du bruke CLKComplicationTemplateModularLargeStandardBody mal, som viser tre linjer med tekst. For hvert TV-program vil disse tre linjene være:
Det finnes ganske mange maler tilgjengelig over de fem komplikasjonsfamiliene. Følgende bilde viser de tilgjengelige maler og fremhever den som vi skal bruke i denne opplæringen.
Bildekreditt: Skape komplikasjoner med ClockKit (WWDC 2015)Fordi plass for innhold er begrenset på en klokkevisning, enda mer i de små størrelsene på komplikasjoner på klokken, gir du tekstbasert data til ClockKit, ved hjelp av CLKTextProvider objekter. Disse tilbyderne har som mål å unngå trunkerende innhold, noe som resulterer i en dårlig brukeropplevelse. Med disse tekstleverandørene beskriver du dine intensjoner om hvilket innhold du vil vises, og deretter håndterer ClockKit den endelige formateringen for deg.
For eksempel, hvis du vil vise en dato i komplikasjonen, bruker du CLKDateTextProvider med en spesifisert dato og sett av enheter (måned, dag, time, etc.). Det vil formatere datoen for ledig plass riktig. Et eksempel på dette ville være å ta datoen "torsdag 22. oktober" og kunne formatere den til:
For en komplett liste over tekstleverandører og maler tilgjengelig i ClockKit, kan du se på Apples ClockKit Framework Reference.
Nå som du vet om grunnleggende maler og tekstleverandører, er du klar til å lage en mal for komplikasjonen din. I getPlaceHolderTemplateForComplication (_: withHandler :) metode, legg til følgende kode:
Funk getPlaceholderTemplateForComplication (komplikasjon: CLKComplication, withHandler handler: (CLKComplicationTemplate?) -> Feid) // Denne metoden vil bli kalt en gang per komplikasjon, og resultatene vil bli cachelagret la template = CLKComplicationTemplateModularLargeStandardBody () template.headerTextProvider = CLKTimeIntervalTextProvider (startDate : NSDate (), endDate: NSDate (timeIntervalSinceNow: 60 * 60 * 1.5)) template.body1TextProvider = CLKSimpleTextProvider (tekst: "Vis navn", shortText: "Name") template.body2TextProvider = CLKSimpleTextProvider (tekst: "Show Genre" shortText: null) handler (mal)
Med denne koden oppretter du en Standard kropp mal for Modular Large familie og gi den tre tekstleverandører. De CLKSimpleTextProvider objekter bør være rettferdig. De CLKTimeIntervalTextProvider tar to datoer og formaterer dem i en streng, for eksempel "10:00 AM-3:30 PM" eller "1: 00-2: 45 PM".
Nå som vi har konfigurert vår tidslinje og gitt ClockKit en mal for komplikasjonen, kan vi endelig teste resultatene av vårt arbeid. Øverst til venstre i Xcode-vinduet, velg ditt komplikasjonsmål og en av de tilgjengelige simulatorene. Klikk på avspillingsknappen for å bygge og kjøre appen din.
Når Apple Watch-simulatoren lanserer, vil du sannsynligvis bli presentert med følgende visningsansikt:
For å teste komplikasjonen din, må du fullføre noen få trinn.
trykk Command + Shift + 2 å simulere en kraftrør og klikk på klokkeansiktet.
trykk Command + Shift + 1, sveip til høyre til Modular ansikt og klikk på Tilpass knapp.
Sveip til høyre, trykk på den midtre komplikasjonen, og bla til bunnen, ved hjelp av styreflaten eller musen for å simulere den digitale kronen.
Simuler en kraft-berøring igjen for å komme tilbake til klokkefokusvelgeren og velg Modular ansikt.
Gratulerer. Du har nettopp fått deg aller første ClockKit-komplikasjon som dukker opp på et Apple Watch-ansikt. Nå er det på tide for deg å begynne å fylle ut det med noen faktiske (falske) data.
Før vi lager noen tidslinjeposter for komplikasjonen, skal vi først lage en Vise fram struct for å enkelt modellere våre data og deretter lage verdier av denne nye typen. Legg til følgende kodestykke til ComplicationController.swift, før starten av ComplicationController klassen definisjon.
struct Vis var navn: String var shortName: String? var genre: String var startDate: NSDate varlengde: NSTimeInterval la time: NSTimeInterval = 60 * 60 la viser = [Vis (navn: "Into the Wild", shortName: "Into Wild", sjanger: "Documentary", startDate: NSDate (), lengde: time * 1,5), Vis (navn: "24/7", shortName: null, sjanger: "Drama", startDate: NSDate (timeIntervalSinceNow: time * 1.5), lengde: time), Vis : "Hvordan bli rik", shortName: "Bli rik", sjanger: "Dokumentar", startDate: NSDate (timeIntervalSinceNow: time * 2.5), lengde: time * 3), Vis (navn: "NET Daily", shortName: null, genre: "Nyheter", startDate: NSDate (timeIntervalSinceNow: time * 5.5), lengde: time)]
Som du ser, lager vi Vise fram struktur og opprett en statisk matrise som inneholder fire viser. Du vil bruke dette arrayet som komplikasjonens datakilde.
I ComplicationController klasse, finn getCurrentTimelineEntryForComplication (_: withHandler :) metode og legg til følgende kode for det:
Funk getCurrentTimelineEntryForComplication (komplikasjon: CLKComplication, withHandler Handler: ((CLKComplicationTimelineEntry?) -> Feid)) // Ring handleren med gjeldende tidslinjeoppføring la show = viser [0] la template = CLKComplicationTemplateModularLargeStandardBody () template.headerTextProvider = CLKTimeIntervalTextProvider startDate: show.startDate, endDate: NSDate (timeInterval: show.length, sinceDate: show.startDate)) template.body1TextProvider = CLKSimpleTextProvider (tekst: show.name, shortText: show.shortName) template.body2TextProvider = CLKSimpleTextProvider (tekst: show .genre, shortText: null) la entry = CLKComplicationTimelineEntry (dato: NSDate (timeInterval: time * -0.25, sinceDate: show.startDate), complicationTemplate: template) handler (entry)
Du oppretter først en komplikasjonsmal, akkurat som du gjorde før, og fyller den med innhold. Deretter oppretter du en CLKComplicationTimelineEntry objekt med to parametere:
Datoen du spesifiserer her er hvor denne oppføringen vil bli plassert på tidslinjen og vist til brukeren. For vår app, gir vi vår tidslinjeoppføring en dato på femten minutter før showet skal begynne slik at det vil vises på brukerens klokke like før showet er på.
Deretter må du oppgi ClockKit med alle de andre showene du har opprettet for komplikasjonen din. Dette gjøres i getTimelineEntriesForComplication (_: afterDate: grense: withHandler :) metode. Grenseparameteren i denne metoden er der, slik at en enkelt applikasjon ikke kan overbelaste ClockKit-cachen med data og vet nøyaktig hvor mange tidslinjeposter det må gi.
Legg til følgende kode i getTimelineEntriesForComplication (_: afterDate: grense: withHandler :) metode i ComplicationController.swift:
Funk getTimelineEntriesForComplication (komplikasjon: CLKComplication, afterDate dato: NSDate, limit: Int, medHandler handler: (([CLKComplicationTimelineEntry]?) -> Feid)) // Ring handleren med tidslinjepostene etter den oppgitte datoen var entries: [ CLKComplicationTimelineEntry] = [] for show i show if entries.count < limit && show.startDate.timeIntervalSinceDate(date) > 0 la template = CLKComplicationTemplateModularLargeStandardBody () template.headerTextProvider = CLKTimeIntervalTextProvider (startDate: show.startDate, endDate: NSDate (timeInterval: show.length, sinceDate: show.startDate)) template.body1TextProvider = CLKSimpleTextProvider (tekst: show.name, shortText : show.shortName) template.body2TextProvider = CLKSimpleTextProvider (tekst: show.genre, shortText: null) la entry = CLKComplicationTimelineEntry (dato: NSDate (timeInterval: time * -0.25, sinceDate: show.startDate), complicationTemplate: template) oppføringer. legge til (oppføring) handler (oppføringer)
Du lager først en tom rekke av CLKComplicationTimelineEntry objekter. Du deretter iterere gjennom showene du opprettet tidligere. For hvert show, hvis det starter etter datoen som er gitt av ClockKit, og grensen for oppføringene ikke er overskredet, lager du en mal og legger til denne i arrayen.
På slutten av denne metoden, ringer du håndtereren med matrisen din. Passering nil eller en tom rekkefølge til håndtereren vil fortelle ClockKit at du ikke har flere data å gi, og det vil slutte å spørre din CLKComplicationDataSource objekt til flere data kreves.
Med disse metodene på plass, er du nå klar til å se din fullførte komplikasjon. Klikk på avspillingsknappen for å bygge og kjøre appen din. Når simulatoren først starter, vil du se komplikasjonen din som viser dataene til det første showet du opprettet.
Hvis du deretter ruller med styreflaten eller musen for å gå inn i Time Travel-modus, vil du se at den andre viser at du har opprettet, vises ved komplikasjonen din på riktig tidspunkt.
I denne opplæringen har du lært grunnleggende for ClockKit-rammen og hvordan du oppretter en tilpasset klokkeslettkomplikasjon for Apple Watch. Dette inkluderte de fem komplikasjonsfamiliene, grunnleggende maler og tekstleverandører, og tidslinjebaserte data.
I din komplikasjon har du også bygget inn støtte til watchOS 2 tidsreiser og legger til nye data ettersom tiden utvikler seg. Som alltid, hvis du har noen kommentarer eller spørsmål, la dem være i kommentarene nedenfor.
Accentsconagua