Swift Academy · Lekcja

Rejestrowanie powiadomień push

Żądanie pozwolenia i uzyskiwanie tokenu urządzenia.

Lekcja 1 z 413 kroki

Rejestrowanie powiadomień push to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 1 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.

Jak działa push od początku do końca

Powiadomienie push trafia z serwera, przez Apple Push Notification service (APNs), do konkretnego urządzenia. Urządzenie potwierdza swoją tożsamość za pomocą tokenu urządzenia wydanego przez APNs. Zanim to nastąpi, użytkownik musi wyrazić zgodę, a aplikacja musi się zarejestrować.

// Flow: App registers -> APNs returns device token ->
// you send token to your server -> server pushes via APNs

Notification Center

UNUserNotificationCenter to jeden obiekt używany do wszystkiego, co dotyczy powiadomień lokalnych i zdalnych: żądania autoryzacji, ustawienia delegata, planowania powiadomień lokalnych i odczytywania ustawień. Pobierz współdzieloną instancję.

import UserNotifications
let center = UNUserNotificationCenter.current()
// All notification configuration goes through center

Żądanie autoryzacji

Zanim wyświetlisz powiadomienia, musisz poprosić użytkownika o zgodę. requestAuthorization(options:) wyświetla systemowy monit i zwraca informację, czy użytkownik wyraził zgodę. Żądaj tylko potrzebnych opcji: .alert, .sound, .badge.

import UserNotifications
func requestAuth() async throws -> Bool {
    let center = UNUserNotificationCenter.current()
    return try await center.requestAuthorization(
        options: [.alert, .sound, .badge])
}

Rejestrowanie w APNs

Autoryzacja jest niezależna od rejestracji. Po uzyskaniu zgody lub równocześnie z jej uzyskiwaniem wywołaj registerForRemoteNotifications() w main actor. Spowoduje to żądanie tokenu urządzenia od APNs. Wywołanie musi nastąpić w głównym wątku.

import UIKit
@MainActor
func registerForPush() {
    UIApplication.shared.registerForRemoteNotifications()
}

Odbieranie tokenu urządzenia

Po pomyślnej rejestracji metoda didRegisterForRemoteNotificationsWithDeviceToken delegata aplikacji zostaje wywołana z tokenem typu Data. Konwertujesz go na ciąg szesnastkowy i wysyłasz na serwer, który używa go do kierowania powiadomień do tego urządzenia.

import UIKit
func application(
    _ app: UIApplication,
    didRegisterForRemoteNotificationsWithDeviceToken
    deviceToken: Data) {
    let token = deviceToken.map {
        String(format: "%02x", $0) }.joined()
    print("APNs token:", token)
    // send token to your backend
}

Obsługa niepowodzenia rejestracji

Rejestracja może się nie udać z powodu braku sieci, braku uprawnienia APNs lub uruchomienia w nieobsługiwanym środowisku. Zaimplementuj didFailToRegisterForRemoteNotificationsWithError, aby rejestrować błąd i przeprowadzić kontrolowane odzyskiwanie zamiast doprowadzać do awarii aplikacji.

import UIKit
func application(
    _ app: UIApplication,
    didFailToRegisterForRemoteNotificationsWithError
    error: Error) {
    print("Push registration failed:", error)
}

Tokeny mogą się zmieniać

Token urządzenia nie jest stały. Zmienia się, gdy użytkownik odtwarza dane z kopii zapasowej, ponownie instaluje aplikację lub przechodzi na nowe urządzenie. Rejestruj token przy każdym uruchomieniu i wysyłaj najnowszy na serwer, zastępując nim poprzedni.

// Best practice: register on each launch,
// always upload the freshly received token,
// never cache a token as permanent.
let rule = "re-register every launch"
_ = rule

Sprawdzanie bieżących ustawień

Użytkownik może później cofnąć zgodę w Ustawieniach. Zanim zaczniesz polegać na powiadomieniach, odczytaj getNotificationSettings, aby sprawdzić bieżący status autoryzacji i dozwolone funkcje.

import UserNotifications
func currentStatus() async -> UNAuthorizationStatus {
    let settings = await UNUserNotificationCenter
        .current().notificationSettings()
    return settings.authorizationStatus
}

Autoryzacja tymczasowa

Opcja .provisional pozwala dostarczać powiadomienia po cichu do Notification Center bez wyświetlania monitu na początku. To świetny sposób, aby użytkownicy mogli wypróbować powiadomienia przed podjęciem decyzji, czy je zachować, czy wyłączyć.

import UserNotifications
func requestQuiet() async throws -> Bool {
    try await UNUserNotificationCenter.current()
        .requestAuthorization(
            options: [.alert, .sound, .provisional])
}

Wymagana funkcja

Żadne z tych działań nie zadziała bez włączenia funkcji Push Notifications w celu Xcode, która dodaje uprawnienie aps-environment. Aby umożliwić dostarczanie w tle, włącz również funkcję Background Modes z opcją Remote notifications.

// Xcode target > Signing & Capabilities:
//   + Push Notifications
//   + Background Modes > Remote notifications
let caps = "entitlements required"
_ = caps

Kompletny proces rejestracji

Przejrzysty proces uruchamiania wygląda tak: poproś o autoryzację, a jeśli zostanie przyznana, zarejestruj aplikację do obsługi zdalnych powiadomień w main actor. Następnie token pojawi się w wywołaniu zwrotnym delegata i będzie można go wysłać na serwer.

import UIKit
import UserNotifications
func setupPush() async {
    let center = UNUserNotificationCenter.current()
    let granted = (try? await center.requestAuthorization(
        options: [.alert, .sound, .badge])) ?? false
    if granted {
        await MainActor.run {
            UIApplication.shared.registerForRemoteNotifications()
        }
    }
}

Szybki test

Przypomnij sobie zależność między autoryzacją a rejestracją.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Nauczyli się Państwo, jak zarejestrować aplikację do obsługi powiadomień push:

Należy użyć UNUserNotificationCenter, aby poprosić o zgodę na .alert/.sound/.badge.
Uzyskanie zgody i rejestracja to oddzielne operacje; należy wywołać registerForRemoteNotifications() na głównym aktorze.
Należy przekonwertować token Data na zapis szesnastkowy i przesłać go na serwer; rejestrację trzeba ponawiać przy każdym uruchomieniu, ponieważ tokeny się zmieniają.
Należy włączyć możliwość Push Notifications i rozważyć zgodę .provisional.

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 „Rejestrowanie powiadomień push” jest bezpłatna?

Tak — pełny tekst „Rejestrowanie powiadomień push” 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 „Rejestrowanie powiadomień push”?

Żądanie pozwolenia i uzyskiwanie tokenu urządzenia. Ć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 1 z 4.

Ile czasu zajmuje lekcja „Rejestrowanie powiadomień push”?

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