Swift Academy · Lekcja

Obsługa ładunków powiadomień

Reagowanie na powiadomienia na pierwszym planie i w tle.

Lekcja 2 z 413 kroki

Obsługa ładunków powiadomień to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Struktura payloadu

Powiadomienie zdalne to słownik JSON, który serwer wysyła do APNs. Zarezerwowany klucz aps zawiera treści widoczne dla użytkownika — alert, dźwięk i plakietkę — natomiast pozostałe klucze zawierają własne dane, na przykład identyfikator elementu, który należy otworzyć.

// Example payload JSON:
// {
//   "aps": { "alert": { "title": "Hi", "body": "..." },
//            "sound": "default", "badge": 1 },
//   "itemId": "42"
// }

Słownik aps

Wewnątrz aps element alert może być ciągiem znaków albo obiektem zawierającym tytuł, treść i podtytuł. Znajdują się tu również sound, badge oraz flagi, takie jak content-available i mutable-content. Wszystko poza aps można zdefiniować samodzielnie.

// aps keys:
//   alert: { title, subtitle, body }
//   sound: "default" or critical sound object
//   badge: Int
//   content-available: 1  (silent / background)
//   mutable-content: 1    (allow modification)

Dostarczanie na pierwszym planie

Domyślnie powiadomienie odebrane, gdy aplikacja działa na pierwszym planie, nie jest wyświetlane. Aby mimo to je pokazać, należy zaimplementować metodę delegata willPresent i zwrócić wybrane opcje prezentacji, na przykład baner oraz dźwięk.

import UserNotifications
func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    willPresent notification: UNNotification
) async -> UNNotificationPresentationOptions {
    return [.banner, .sound, .badge]
}

Reakcja na dotknięcie

Gdy użytkownik dotknie powiadomienia — niezależnie od tego, czy aplikacja działała w tle, czy została zamknięta — wywoływana jest metoda delegata didReceive response. W tym miejscu należy odczytać payload i przejść do właściwego ekranu.

import UserNotifications
func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse
) async {
    let info = response.notification.request
        .content.userInfo
    if let id = info["itemId"] as? String {
        print("open item", id)
    }
}

Odczytywanie userInfo

Pełny payload, w tym własne klucze, jest dostępny jako content.userInfo — słownik [AnyHashable: Any]. Każdą wartość należy rzutować ostrożnie; nie wolno wymuszać rozpakowania, ponieważ niepoprawny payload nie powinien powodować awarii aplikacji.

import UserNotifications
func route(_ userInfo: [AnyHashable: Any]) {
    guard let screen = userInfo["screen"] as? String
    else { return }
    switch screen {
    case "profile": print("go to profile")
    case "cart":    print("go to cart")
    default:        break
    }
}

Ciche powiadomienia (w tle)

Ustawienie content-available: 1 i pominięcie alertu tworzy ciche powiadomienie push, które wybudza aplikację działającą w tle w celu pobrania danych, bez wyświetlania interfejsu. Takie powiadomienia są ograniczane przez system i wymagają trybu działania w tle Remote notifications.

// Silent payload — no alert, just a wake-up:
// { "aps": { "content-available": 1 }, "sync": true }
let silent = "content-available wakes app quietly"
_ = silent

Procedura obsługi pobierania w tle

Ciche powiadomienie trafia do asynchronicznej metody delegata aplikacji didReceiveRemoteNotification. Należy wykonać pobieranie i zwrócić wartość UIBackgroundFetchResult, aby system wiedział, czy pojawiły się nowe dane, i mógł odpowiednio zaplanować przyszłe wybudzenia.

import UIKit
func application(
    _ app: UIApplication,
    didReceiveRemoteNotification userInfo: [AnyHashable: Any]
) async -> UIBackgroundFetchResult {
    // fetch fresh data here
    return .newData
}

Modyfikowanie treści i rozszerzenia usług

Po ustawieniu mutable-content: 1 Notification Service Extension może przechwycić powiadomienie przed jego wyświetleniem — aby odszyfrować treść, pobrać załącznik graficzny lub zmienić tytuł. Rozszerzenie ma niewiele czasu na zakończenie działania.

// Service extension entry point (UNNotificationServiceExtension):
// override didReceive(_:withContentHandler:)
//   modify bestAttemptContent, then call contentHandler
let mutable = "mutable-content enables interception"
_ = mutable

Lokalizowanie alertu

Aby lokalizować tekst po stronie serwera, należy wysłać title-loc-key i loc-key wskazujące klucze w plikach Localizable aplikacji, a także loc-args z wartościami do podstawienia. Urządzenie wyświetli je w języku użytkownika, bez konieczności wysyłania wcześniej przetłumaczonej treści.

// Localized alert payload:
// "alert": {
//   "loc-key": "NEW_MESSAGE",
//   "loc-args": ["Ada"]
// }
let localized = "loc-key resolves on device"
_ = localized

Aktualizowanie plakietki

Wartość badge ustawia liczbę wyświetlaną na ikonie aplikacji. Wysłanie badge: 0 usuwa tę liczbę. Można ją również ustawić w kodzie za pomocą setBadgeCount po przeczytaniu treści przez użytkownika, aby plakietka odpowiadała liczbie nieprzeczytanych elementów.

import UserNotifications
func clearBadge() async {
    try? await UNUserNotificationCenter.current()
        .setBadgeCount(0)
}

Solidna procedura obsługi

Należy połączyć wszystkie elementy: wyświetlać powiadomienia na pierwszym planie, obsługiwać dotknięcia i sprawdzać każde rzutowanie. Procedura obsługi nigdy nie powinna powodować awarii z powodu nieoczekiwanego payloadu i zawsze powinna wyodrębnić wszystkie dostępne dane.

import UserNotifications
func handleTap(_ response: UNNotificationResponse) {
    let info = response.notification.request
        .content.userInfo
    guard let id = info["itemId"] as? String else {
        print("no item id; open home")
        return
    }
    print("navigate to item", id)
}

Szybkie sprawdzenie

Proszę przypomnieć sobie, jak reagować na dotknięcie powiadomienia.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Nauczyli się Państwo obsługi payloadów:

Słownik aps zawiera treści widoczne dla użytkownika, a pozostałe klucze — własne dane, odczytywane za pośrednictwem userInfo.
Należy przesłonić willPresent, aby wyświetlać powiadomienia na pierwszym planie, oraz didReceive response, aby obsługiwać dotknięcia.
content-available: 1 uruchamia ciche pobieranie danych w tle, które zwraca wartość UIBackgroundFetchResult.
mutable-content włącza rozszerzenie usługi, a loc-key umożliwia lokalizowanie tekstu na urządzeniu.

Bezpłatny start

Ucz się Swift dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 122
Lekcje: 409

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Obsługa ładunków powiadomień” jest bezpłatna?

Tak — pełny tekst „Obsługa ładunków powiadomień” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Obsługa ładunków powiadomień”?

Reagowanie na powiadomienia na pierwszym planie i w tle. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Obsługa ładunków powiadomień”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Swift Academy