Share
Al WWDC 2015, Apple ha annunciato il suo primo importante aggiornamento del software Apple Watch, watchOS 2. Questo nuovo aggiornamento ha portato con sé molte nuove API e funzionalità da sfruttare per gli sviluppatori, incluse app native, accesso a più hardware Apple Watch e una migliore comunicazione con l'app iOS principale.
In questo tutorial, ti mostrerò come sfruttare un'altra nuova funzionalità, la possibilità di creare complicazioni personalizzate dell'orologio utilizzando il framework ClockKit. Questo tutorial richiede che tu stia correndo Xcode 7 sopra OS X Yosemite (10.10) o successivo.
Se non lo sai già, le complicazioni di Apple Watch sono i piccoli elementi dell'interfaccia che visualizzano le informazioni sul quadrante.
L'immagine sopra mostra come vengono visualizzate cinque complicazioni sul componibile quadrante oltre al tempo nell'angolo in alto a destra.
Crea un nuovo progetto in Xcode, usando il watchOS> Applicazione> App iOS con l'app WatchKit modello.
Quindi, configura il progetto come mostrato di seguito, assicurandosi che Includi Complicazione è controllato.
Una volta che Xcode ha creato il tuo progetto, apri il ClockKit Introduzione Estensione di WatchKit nel Project Navigator. Vedrai un nuovo Configurazione delle complicazioni sezione come mostrato di seguito.
Le cinque caselle di controllo sotto Famiglie supportate rappresentano le diverse famiglie di complicazioni supportate dalla tua app. In questo tutorial, ci concentreremo sul Modulare Grande famiglia. Puoi deselezionare le altre caselle di controllo per ora.
Come affermato in Apple watchOS 2 Guida alla transizione, è altamente consigliato che la tua app supporti tutte e cinque le famiglie. L'immagine seguente mostra dove vengono utilizzate queste diverse famiglie.
Immagine di credito: Apple watchOS 2 Transition GuidePer insegnarti come usare ClockKit, creerai una semplice complicazione che mostra l'ora, il nome e il genere di programmi TV falsi su una particolare stazione per tutto il giorno.
Per iniziare, apri ComplicationController.swift nel ClockKit Introduzione Estensione di WatchKit cartella. Xcode ha creato automaticamente questo file per te. Contiene a ComplicationController classe, che si conforma e implementa il CLKComplicationDataSource protocollo.
I metodi associati a questo protocollo sono come fornire dati a ClockKit sulle complicazioni che si desidera mostrare. I metodi del protocollo contengono un gestore che è necessario chiamare per passare i dati a ClockKit.
Quando fornisci dati a ClockKit, lo fai sotto forma di timeline. A tale scopo, riempi la sequenza temporale della tua complicazione con gli oggetti dati collegati a un momento specifico. Questi oggetti dati sono modellati dal CLKComplicationTimelineEntry classe. Quando viene raggiunto un determinato punto nel tempo, ClockKit visualizza automaticamente il contenuto corretto per la tua app.
Le voci della timeline vengono recuperate e memorizzate nella cache da ClockKit molto prima dell'ora in cui devono essere visualizzate. Ciò significa che i dati devono poter essere recuperati e programmati in anticipo. Ogni applicazione ha un budget limitato di tempo per aggiornare i suoi contenuti in background. In altre parole, le complicazioni sono non una sostituzione per le notifiche push o il centro di notifica.
Il principale vantaggio di fornire dati in questo modo è di mantenere un'esperienza utente eccellente. Il contenuto per ogni complicazione è immediatamente disponibile quando l'utente alza il polso. Uno degli altri vantaggi dell'utilizzo di questo modello di dati timeline è la possibilità di adottare facilmente il nuovo Viaggio nel tempo funzione in watchOS 2. Questo è quando l'utente gira la corona digitale mentre guarda il quadrante e i dati delle complicazioni riflettono il tempo che è stato viaggiato a.
Nel tuo codice, sotto il Configurazione della linea temporale mark, vedrai quattro metodi che sono necessari per configurare la timeline. Per rendere questo tutorial semplice e facile da capire, supporteremo solo i viaggi nel tempo e forniremo dati per un massimo di 24 ore. Per fare ciò, ha aggiornato l'implementazione dei primi tre metodi come mostrato di seguito.
func getSupportedTimeTravelDirectionsForComplication (complicazione: CLKComplication, withHandler handler: (CLKComplicationTimeTravelDirections) -> Void) handler (.Forward) func getTimelineStartDateForComplication (complicazione: CLKComplication, withHandler handler: (NSDate?) -> Void) handler (NSDate ()) func getTimelineEndDateForComplication (complicazione: CLKComplication, withHandler handler: (NSDate?) -> Void) handler (NSDate (timeIntervalSinceNow: (60 * 60 * 24)))
Il quarto metodo nel Configurazione della linea temporale sezione, getPrivacyBehaviorForComplication (_: withHandler :), è usato per specificare se vuoi che il contenuto della tua complicazione sia mostrato o meno quando il dispositivo è bloccato o meno. Il valore predefinito passato al gestore, ShowOnLockScreen, significa che i dati saranno sempre visibili.
Scorri fino alla fine del ComplicationController classe e trova il getPlaceHolderTemplateForComplication (_: withHandler :) metodo. In questo metodo, crei e passi a CLKComplicationTemplate torna al gestore per i dati che desideri mostrare. In questo tutorial, userai il CLKComplicationTemplateModularLargeStandardBody modello, che visualizza tre righe di testo. Per ogni programma TV, queste tre linee saranno:
Ci sono alcuni modelli disponibili tra le cinque famiglie di complicanze. L'immagine seguente mostra i modelli disponibili ed evidenzia quella che useremo in questo tutorial.
Credito immagine: creazione di complicazioni con ClockKit (WWDC 2015)Poiché lo spazio per i contenuti è limitato su un display dell'orologio, ancora di più nelle piccole dimensioni delle complicazioni del quadrante, si forniscono dati basati su testo a ClockKit, utilizzando CLKTextProvider oggetti. Questi provider mirano a evitare il troncamento dei contenuti, il che comporta un'esperienza utente negativa. Con questi fornitori di testi, descrivi le tue intenzioni su quale contenuto vuoi visualizzare e quindi ClockKit gestisce la formattazione finale per te.
Ad esempio, se si desidera visualizzare una data nella propria complicazione, si utilizza il CLKDateTextProvider con una data e un set di unità specifici (mese, giorno, ora, ecc.). Questo formatterà correttamente la data per lo spazio disponibile. Un esempio di questo sarebbe prendere la data "giovedì 22 ottobre" ed essere in grado di formattarlo per:
Per un elenco completo dei provider di testo e dei modelli disponibili in ClockKit, è possibile consultare il riferimento a ClockKit Framework di Apple.
Ora che conosci i modelli di base e i provider di testo, sei pronto per creare un modello per le tue complicazioni. Nel getPlaceHolderTemplateForComplication (_: withHandler :) metodo, aggiungi il seguente codice:
func getPlaceholderTemplateForComplication (complicazione: CLKComplication, withHandler handler: (CLKComplicationTemplate?) -> Void) // Questo metodo verrà chiamato una volta per complicazione supportata e i risultati verranno memorizzati nella cache let template = CLKTemplateModularLargeStandardBody () template.headerTextProvider = CLKTimeIntervalTextProvider (startDate : NSDate (), endDate: NSDate (timeIntervalSinceNow: 60 * 60 * 1.5)) template.body1TextProvider = CLKSimpleTextProvider (testo: "Show Name", shortText: "Name") template.body2TextProvider = CLKSimpleTextProvider (testo: "Mostra genere", shortText: nil) handler (template)
Con questo codice, crei a Corpo standard modello per il Modulare Grande famiglia e dargli tre fornitori di testi. Il CLKSimpleTextProvider gli oggetti dovrebbero essere semplici. Il CLKTimeIntervalTextProvider prende due date e le formatta in una stringa, ad esempio "10:00 AM-3:30PM" o "1: 00-2: 45PM".
Ora che abbiamo configurato la nostra timeline e fornito a ClockKit un modello per le nostre complicazioni, possiamo finalmente testare i risultati del nostro lavoro. Nella parte in alto a sinistra della finestra Xcode, scegli il tuo obiettivo di complicazione e uno dei simulatori disponibili. Fai clic sul pulsante di riproduzione per creare ed eseguire la tua app.
Quando verrà lanciato il simulatore di Apple Watch, molto probabilmente verrà presentato il seguente quadrante:
Per testare la tua complicazione, è necessario completare alcuni passaggi.
stampa Comando + Maiusc + 2 per simulare un tocco di forza e fare clic sul quadrante.
stampa Command + Shift + 1, scorri verso destra per componibile faccia e clicca sul personalizzare pulsante.
Scorri verso destra, tocca la complicazione centrale e scorri verso il basso, utilizzando il trackpad o il mouse per simulare la corona digitale.
Simula di nuovo un tocco di forza per tornare al selettore del quadrante e scegli il componibile viso.
Congratulazioni. Hai appena ottenuto la prima complicazione di ClockKit per apparire su un quadrante Apple Watch. Ora è il momento di iniziare a riempirlo con alcuni dati (falsi) effettivi.
Prima di creare qualsiasi voce della timeline per la nostra complicazione, creeremo prima un Mostrare struct per modellare facilmente i nostri dati e quindi creare valori di questo nuovo tipo. Aggiungi il seguente snippet di codice a ComplicationController.swift, prima dell'inizio del ComplicationController definizione della classe.
struct Mostra var name: String var shortName: String? var genere: String var startDate: NSDate var length: NSTimeInterval let hour: NSTimeInterval = 60 * 60 let shows = [Mostra (nome: "Into the Wild", shortName: "Into Wild", genere: "Documentary", startDate: NSDate (), length: hour * 1.5), Show (nome: "24/7", shortName: nil, genere: "Drama", startDate: NSDate (timeIntervalSinceNow: hour * 1.5), length: hour), Show (nome : "Come diventare ricchi", shortName: "Diventa ricco", genere: "Documentario", data di inizio: NSDate (timeIntervalSinceNow: hour * 2.5), lunghezza: hour * 3), Show (nome: "NET Daily", shortName: nil, genere: "News", startDate: NSDate (timeIntervalSinceNow: hour * 5.5), length: hour)]
Come puoi vedere, creiamo il Mostrare struttura e creare una matrice statica che contiene quattro spettacoli. Userai questo array come origine dati della tua complicanza.
Nel ComplicationController classe, trova il getCurrentTimelineEntryForComplication (_: withHandler :) metodo e aggiungere il seguente codice ad esso:
func getCurrentTimelineEntryForComplication (complicazione: CLKComplication, withHandler handler: ((CLKComplicationTimelineEntry?) -> Void)) // Chiama il gestore con la voce della timeline corrente let show = shows [0] let template = CLKComplicationTemplateModularLargeStandardBody () template.headerTextProvider = CLKTimeIntervalTextProvider ( startDate: show.startDate, endDate: NSDate (timeInterval: show.length, sinceDate: show.startDate)) template.body1TextProvider = CLKSimpleTextProvider (testo: show.name, shortText: show.shortName) template.body2TextProvider = CLKSimpleTextProvider (testo: mostra .genre, shortText: nil) let entry = CLKComplicationTimelineEntry (data: NSDate (timeInterval: hour * -0.25, sinceDate: show.startDate), complationTemplate: template) handler (voce)
Per prima cosa crea un modello di complicazione, proprio come hai fatto prima, e riempilo di contenuti. Quindi crei un CLKComplicationTimelineEntry oggetto con due parametri:
La data specificata qui è dove questa voce sarà posizionata sulla timeline e mostrata all'utente. Per la nostra app, forniamo alla nostra timeline una data di quindici minuti prima dell'inizio dello spettacolo, in modo che venga visualizzato sull'orologio dell'utente appena prima dello spettacolo..
Successivamente, è necessario fornire ClockKit con tutti gli altri spettacoli creati per la propria complicazione. Questo è fatto nel getTimelineEntriesForComplication (_: afterDate: limite: withHandler :) metodo. Il parametro limit in questo metodo è lì in modo che una singola applicazione non possa sovraccaricare la cache di ClockKit con i dati e sa esattamente quante voci della timeline deve fornire.
Aggiungi il seguente codice al getTimelineEntriesForComplication (_: afterDate: limite: withHandler :) metodo in ComplicationController.swift:
func getTimelineEntriesForComplication (complicazione: CLKComplication, data afterDate: NSDate, limit: Int, withHandler handler: (([CLKComplicationTimelineEntry]?) -> Void)) // Chiama il gestore con le voci della timeline dopo le voci var date date: [ CLKComplicationTimelineEntry] = [] per mostrare negli spettacoli if entries.count < limit && show.startDate.timeIntervalSinceDate(date) > 0 let template = CLKComplicationTemplateModularLargeStandardBody () template.headerTextProvider = CLKTimeIntervalTextProvider (startDate: show.startDate, endDate: NSDate (timeInterval: show.length, sinceDate: show.startDate)) template.body1TextProvider = CLKSimpleTextProvider (testo: show.name, shortText : show.shortName) template.body2TextProvider = CLKSimpleTextProvider (text: show.genre, shortText: nil) let entry = CLKComplicationTimelineEntry (date: NSDate (timeInterval: hour * -0.25, sinceDate: show.startDate), complicazioneTemplate: modello) voci. append (entry) handler (entries)
Per prima cosa crea una matrice vuota di CLKComplicationTimelineEntry oggetti. Successivamente, esegui l'iterazione attraverso gli spettacoli creati in precedenza. Per ogni spettacolo, se inizia dopo la data fornita da ClockKit e il limite delle voci non è stato superato, allora si crea un modello e lo si aggiunge all'array.
Alla fine di questo metodo, chiami il gestore con il tuo array. passaggio zero o una matrice vuota al gestore dirà a ClockKit che non hai più dati da fornire e smetterà di interrogare il tuo CLKComplicationDataSource oggetto fino a quando non saranno richiesti più dati.
Con questi metodi, sei pronto per vedere la tua complicazione completata. Fai clic sul pulsante di riproduzione per creare ed eseguire la tua app. Quando il simulatore si avvia per la prima volta, vedrai la tua complicazione mostrare i dati per il primo spettacolo che hai creato.
Se poi scorri con il trackpad o il mouse per accedere alla modalità Viaggio in tempo, vedrai che gli altri spettacoli creati vengono visualizzati dalla tua complicazione al momento giusto.
In questo tutorial, hai appreso i fondamenti del framework ClockKit e come creare una complicazione personalizzata per il quadrante dell'orologio per Apple Watch. Ciò includeva le cinque famiglie di complicanze, i modelli di base e i provider di testo e i dati basati sulla cronologia.
Nella tua complicazione, hai anche supportato la funzione watchOS 2 time travel e aggiungendo nuovi dati con il passare del tempo. Come sempre, se avete commenti o domande, lasciateli nei commenti qui sotto.
Accentsconagua