Accentsconagua
Share
Con iOS 10, tvOS 10 e watchOS 3, Apple sta introducendo un nuovo framework chiamato UserNotifications struttura. Questo nuovissimo set di API offre un modo unificato e orientato agli oggetti di lavorare con le notifiche locali e remote su queste piattaforme. Ciò è particolarmente utile in quanto, rispetto alle API esistenti, le notifiche locali e remote vengono ora gestite in modo molto simile e l'accesso al contenuto delle notifiche non viene più eseguito solo tramite i dizionari.
In questo tutorial, esaminerò le basi di questo nuovo framework e mostrerò come puoi trarne vantaggio per supportare le notifiche per le tue applicazioni.
Questo tutorial richiede che tu stia utilizzando Xcode 8 con gli ultimi SDK iOS, tvOS e watchOS.
Il primo passaggio per qualsiasi notifica di supporto dell'app è richiedere l'autorizzazione dell'utente. Come con le versioni precedenti di iOS, quando si utilizza il framework UserNotifications, è prassi comune eseguirlo non appena l'app termina il lancio.
Prima di utilizzare qualsiasi API UserNotifications, è necessario aggiungere la seguente istruzione import a qualsiasi file di codice Swift che acceda al framework:
import UserNotifications
Quindi, per registrare la tua app per le notifiche, dovrai aggiungere il seguente codice al tuo AppDelegate'S applicazione (_: didFinishLaunchingWithOptions :) metodo:
let center = UNUserNotificationCenter.current () let options: UNAuthorizationOptions = [.alert, .badge, .sound] center.requestAuthorization (options: options) (concesso, errore) in if given application.registerForRemoteNotifications ()
Inizialmente con questo codice, otteniamo un riferimento alla corrente UNUserNotificationCenter oggetto. Successivamente, configuriamo il nostro UNAuthorizationOptions con le funzionalità di notifica vogliamo che la nostra app abbia. Si noti che è possibile avere qualsiasi combinazione di opzioni qui, ad esempio, semplicemente mettere in guardia o entrambi distintivo e suono.
Usando entrambi questi oggetti, chiediamo quindi l'autorizzazione per la nostra app per visualizzare le notifiche chiamando il requestAuthorization (opzioni: completionHandler :) metodo sul nostro UNUserNotificationCenter esempio. Il blocco di codice del gestore di completamento contiene due parametri:
Bool valore che indica se l'autorizzazione è stata concessa o meno dall'utente.Errore oggetto che conterrà informazioni se, per qualche ragione, il sistema non è stato in grado di richiedere l'autorizzazione di notifica per la tua app.Vedrai che nel codice sopra riportato, se l'autorizzazione è concessa dall'utente, ci registreremo quindi per le notifiche remote. Se si desidera implementare notifiche push, è necessaria questa riga di codice. Dovrai anche fare un po 'di setup extra per il tuo progetto, come spiegato in questo tutorial:
Si noti che la registrazione per le notifiche remote invocherà lo stesso UIApplication metodi di callback come nelle precedenti versioni di iOS. Sul successo, applicazione (_: didRegisterForRemoteNotificationsWithDeviceToken :) sarà chiamato, e applicazione (_: didFailToRegisterForRemoteNotificationsWithError :) sarà chiamato in caso di fallimento.
Per questa sezione del tutorial, ci concentreremo interamente sulla pianificazione delle notifiche locali utilizzando il framework UserNotifications. L'invio di notifiche push remote non è cambiato a causa dell'introduzione di questo nuovo framework.
Una notifica locale, prima di essere programmata, è rappresentata da un'istanza di UNNotificationRequest classe. Gli oggetti di questo tipo sono costituiti dai seguenti componenti:
Stringa che consente di distinguere le singole notifiche l'una dall'altra.UNNotificationContent oggetto che contiene tutte le informazioni necessarie per la visualizzazione della notifica, inclusi titolo, sottotitolo e numero di badge dell'app.UNNotificationTrigger oggetto che viene utilizzato dal sistema per determinare quando la tua notifica deve essere "inviata" alla tua app. Per cominciare, esamineremo i vari tipi di trigger che è possibile impostare per le notifiche locali. Il UNNotificationTrigger class è una classe astratta, il che significa che non dovresti mai creare istanze direttamente. Invece, userete le sottoclassi disponibili. Attualmente, il framework UserNotifications fornisce tre per te:
UNTimeIntervalNotificationTrigger, che consente di inviare una notifica per un determinato periodo di tempo dopo la sua pianificazione.UNCalendarNotificationTrigger, che consente di inviare una notifica in una data e un'ora specifiche, indipendentemente dal momento in cui è stata pianificata.UNLocationNotificationTrigger, che consente di inviare una notifica quando l'utente entra o esce da una regione geografica designata.Il codice seguente mostra come è possibile eseguire un trigger di ciascun tipo:
let timeTrigger = UNTimeIntervalNotificationTrigger (timeInterval: 60.0 * 60.0, ripetizioni: false) var date = DateComponents () date.hour = 22 let calendarTrigger = UNCalendarNotificationTrigger (dateMatching: date, ripetizioni: true) let center = CLLocationCoordinate2D (latitude: 40.0, longitude: 120.0) let region = CLCircularRegion (center: center, radius: 500.0, identificatore: "Location") region.notifyOnEntry = true; region.notifyOnExit = false; let locationTrigger = UNLocationNotificationTrigger (region: region, ripetizioni: false)
Con il codice precedente, sono state create le seguenti condizioni di trigger:
timeTrigger sparerà un'ora dopo la pianificazione della notifica. Il Intervallo di tempo parametro passato nel UNTimeIntervalNotificationTrigger inizializzatore è misurato in secondi.calendarTrigger sparerà ripetutamente ogni giorno alle 22:00. La data e l'ora esatte dell'attivazione del trigger possono essere facilmente modificate modificando altre proprietà di DateComponents oggetto che passi nel UNCalendarNotificationTrigger initialiser.locationTrigger si attiva quando l'utente arriva entro 500 metri dalla coordinata designata, in questo caso 40 ° N 120 ° E. Come puoi vedere dal codice, questo tipo di trigger può essere utilizzato per qualsiasi coordinata e / o dimensione della regione e può anche attivare una notifica sia in entrata che in uscita dalla regione.Successivamente, dobbiamo creare il contenuto per la notifica. Questo viene fatto creando un'istanza di UNMutableNotificationContent classe. Questa classe deve essere utilizzata come normale UNNotificationContent la classe ha accesso in sola lettura per le varie proprietà del contenuto della notifica.
Il codice seguente mostra come è possibile creare il contenuto per una notifica di base:
let content = UNMutableNotificationContent () content.title = "Titolo di notifica" content.subtitle = "Sottotitolo di notifica" content.body = "Alcune informazioni sul corpo di notifica da visualizzare." content.badge = 1 content.sound = UNNotificationSound.default ()
Se si desidera un elenco completo delle proprietà disponibili, si prega di dare un'occhiata al UNMutableNotificationContent riferimento di classe.
Infine, ora abbiamo solo bisogno di creare il UNNotificationRequest oggetto e programmarlo. Questo può essere fatto con il seguente codice:
let request = UNNotificationRequest (identificatore: "LocalNotification", content: content, trigger: timeTrigger) UNUserNotificationCenter.current (). add (request) error in if let error = error // Fai qualcosa con error else // Request è stato aggiunto con successo
Inizialmente con questo codice, creiamo l'oggetto richiesta passando un identificatore, oggetto contenuto e trigger nell'inizializzatore. Quindi chiamiamo il aggiungere (_: completionHandler :) metodo sulla corrente UNUserNotificationCenter oggetto e utilizzare il gestore di completamento per eseguire la logica in base al fatto che la notifica fosse pianificata o meno correttamente.
Quando si utilizza il framework UserNotifications, l'elaborazione delle notifiche in arrivo viene gestita da un oggetto che si designa conforme a UNUserNotificationCenterDelegate protocollo. Questo oggetto può essere qualsiasi cosa tu voglia e non deve essere il delegato dell'app come nelle precedenti versioni di iOS.
Una cosa importante da notare, però, è che devi impostare il tuo delegato prima che la tua app sia stata completamente lanciata. Per un'app iOS, ciò significa che è necessario assegnare il proprio delegato all'interno del applicazione (_: willFinishLaunchingWithOptions :) o applicazione (_: didFinishLaunchingWithOptions :) metodo del delegato dell'app. L'impostazione del delegato per le notifiche degli utenti avviene molto facilmente con il seguente codice:
UNUserNotificationCenter.current (). Delegate = delegateObject
Ora con il tuo delegato impostato, quando viene ricevuta una notifica dall'app, ci sono solo due metodi di cui devi preoccuparti. Entrambi i metodi sono passati a UNNotification oggetto, che rappresenta la notifica ricevuta. Questo oggetto contiene a Data proprietà, che ti dice esattamente quando è stata consegnata la notifica, e a richiesta proprietà, che è un'istanza del UNNotificationRequest classe menzionata in precedenza. Da questo oggetto di richiesta, è possibile accedere al contenuto della notifica e (se necessario) il trigger per la notifica. Questo oggetto trigger sarà un'istanza di uno dei UNNotificationTrigger sottoclassi di cui sopra o, nel caso di notifiche push, un'istanza del UNPushNotificationTrigger classe.
Il primo metodo definito dal UNUserNotificationCenterDelegate il protocollo è il userNotificationCenter (_: willPresent: withCompletionHandler :) metodo. Viene chiamato solo quando la tua app è in esecuzione in primo piano e riceve una notifica. Da qui, puoi accedere al contenuto della notifica e visualizzare la tua interfaccia personalizzata all'interno della tua app, se necessario. In alternativa, puoi dire al sistema di presentare la notifica con una varietà di opzioni, come avviene normalmente se la tua app non fosse in esecuzione. Le opzioni disponibili sono:
Il codice seguente mostra un'implementazione di esempio di userNotificationCenter (_: willPresent: withCompletionHandler :) metodo:
func userNotificationCenter (_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) let content = notification.request.content // Elabora contenuto di completamento completionHandler ([. alert, .sound]) / / Visualizza la notifica come avviso normale e suono di riproduzione
L'altro metodo definito dal UNUserNotificationCenterDelegate il protocollo è il userNotificationCenter (_: didReceive: withCompletionHandler :) metodo. Questo metodo viene chiamato quando l'utente interagisce con una notifica per la tua app in qualsiasi modo, incluso il licenziamento o l'apertura dell'app da esso.
Invece di a UNNotification oggetto, questo metodo ha a UNNotificationResponse oggetto passato in esso come parametro. Questo oggetto contiene il UNNotification oggetto che rappresenta la notifica consegnata. Include anche un actionIdentifier proprietà per determinare in che modo l'utente ha interagito con la notifica. Nel caso in cui la notifica venga ignorata o la tua app venga aperta, il framework UserNotifications fornisce identificatori di azione costanti che puoi confrontare con.
Il codice seguente mostra un'implementazione di esempio di userNotificationCenter (_: didReceive: withCompletionHandler :) metodo:
func userNotificationCenter (_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) let actionIdentifier = response.actionIdentifier switch actionIdentifier case UNNotificationDismissAcentifier: // La notifica è stata chiusa dall'utente // Fa qualcosa completionHandler ( ) caso UNNotificationDefaultActionIdentifier: // l'app è stata aperta dalla notifica // esegue qualcosa completionHandler () default: completionHandler ()
Si noti che, per entrambi i metodi delegati, è essenziale chiamare il gestore del completamento non appena si esegue l'elaborazione della notifica. Una volta che lo fai, il sistema sa che hai finito con la notifica e può eseguire tutti i processi necessari, come mettere la notifica nel Centro di notifica dell'utente.
A volte un utente dell'applicazione potrebbe ricevere più notifiche mentre l'app non è in esecuzione. Potrebbero anche aprire la tua app direttamente dalla schermata iniziale e non tramite una notifica. In nessuno di questi casi, nessuno dei due UNUserNotificationCenterDelegate saranno chiamati metodi di protocollo. Quando si lavora con le notifiche locali, a volte si può anche voler rimuovere una notifica pianificata prima che venga visualizzata all'utente.
Per questo motivo, il framework UserNotifications fornisce i seguenti metodi sulla corrente UNUserNotificationCenter istanza per lavorare con notifiche locali in sospeso e notifiche consegnate che non sono ancora state elaborate:
getPendingNotificationRequests (completionHandler :) ti fornisce una serie di UNNotificationRequest oggetti nel gestore di completamento. Questo array conterrà tutte le notifiche locali pianificate che non sono ancora state attivate.removePendingNotificationRequests (withIdentifiers :) rimuove tutte le notifiche locali pianificate con identificativi contenuti in Stringa array in cui passi come parametro.removeAllPendingNotificationRequests rimuove tutte le notifiche locali pianificate per la tua app.getDeliveredNotifications (completionHandler :) ti fornisce una serie di UNNotification oggetti nel gestore di completamento. Questo array conterrà tutte le notifiche fornite per la tua app che sono ancora visibili nel Centro di notifica dell'utente.removeDeliveredNotifications (withIdentifiers :) rimuove tutte le notifiche consegnate con identificativi contenuti in Stringa array che si trasferisce dal Centro di notifica dell'utente.removeAllDeliveredNotifications rimuove tutte le notifiche consegnate per la tua app.Il framework UserNotifications consente inoltre alla tua app di sfruttare le categorie e le azioni di notifica personalizzate introdotte in iOS 8.
Innanzitutto, devi definire le azioni e le categorie personalizzate supportate dall'app UNNotificationAction e UNNotificationCategory classi rispettivamente. Per le azioni in cui si desidera che l'utente possa inserire il testo, è possibile utilizzare il comando UNTextInputNotificationAction classe, che è una sottoclasse di UNNotificationAction. Una volta definite le tue azioni e categorie, devi solo chiamare il setNotificationCategories (_ :) metodo sulla corrente UNUserNotificationCenter esempio. Il codice seguente mostra come è possibile registrare facilmente risposte ed eliminare azioni per una notifica di categoria di messaggi nella propria app:
let replyAction = UNTextInputNotificationAction (identificatore: "com.usernotificationstutorial.reply", titolo: "Rispondi", opzioni: [], textInputButtonTitle: "Invia", textInputPlaceholder: "Digita il tuo messaggio") let deleteAction = UNNotificationAction (identificatore: "com. usernotificationstutorial.delete ", titolo:" Elimina ", opzioni: [.authenticationRequired, .destructive]) let category = UNNotificationCategory (identificatore:" com.usernotificationstutorial.message ", azioni: [replyAction, deleteAction], intentIdentifiers: [], opzioni : []) center.setNotificationCategories ([category])
Successivamente, quando un utente utilizza una delle tue azioni di notifica personalizzate, lo stesso userNotificationCenter (_: didReceive: withCompletionHandler :) viene chiamato il metodo che abbiamo trattato in precedenza. In questo caso, l'identificatore dell'azione del UNNotificationResponse l'oggetto passato sarà uguale a quello che hai definito per la tua azione personalizzata. È anche importante notare che, se l'utente ha interagito con un'azione di notifica di input del testo, l'oggetto risposta passato in questo metodo sarà di tipo UNTextInputNotificationResponse.
Il codice seguente mostra un'implementazione di esempio di questo metodo, inclusa la logica per le azioni create in precedenza:
func userNotificationCenter (_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) let actionIdentifier = response.actionIdentifier consente content = response.notification.request.content switch actionIdentifier case UNNotificationDismissAcentifier: // Notification è stato rimosso dall'utente // Fa qualcosa completionHandler () caso UNNotificationDefaultActionIdentifier: // L'app è stata aperta dalla notifica // Esegui il caso completeHandler () "com.usernotificationstutorial.reply": se let textResponse = response as? UNTextInputNotificationResponse let reply = textResponse.userText // Invia messaggio di risposta completionHandler () caso "com.usernotificationstutorial.delete": // Elimina messaggio completionHandler () default: completionHandler ()
Inoltre, se desideri sfruttare le azioni personalizzate per le tue notifiche locali, puoi semplicemente impostare il comando categoryIdentifier proprietà sul tuo UNMutableNotificationContent oggetto durante la creazione della notifica.
Il nuovo framework UserNotifications fornisce API orientate agli oggetti completamente funzionali e facili da usare per lavorare con notifiche locali e remote su iOS, watchOS e tvOS. Semplifica molto la pianificazione delle notifiche locali per una varietà di scenari e semplifica notevolmente l'intero flusso di elaborazione delle notifiche in entrata e delle azioni personalizzate.
Come sempre, si prega di essere sicuri di lasciare i vostri commenti e feedback nei commenti qui sotto. E dai un'occhiata ad alcuni dei nostri altri articoli e tutorial sulle nuove funzionalità di iOS 10 e watchOS 3!
