Ειδοποιήσεις Push στο .NET MAUI: Οδηγός για Firebase, APNS και Τοπικές Ειδοποιήσεις

Γιατί οι Ειδοποιήσεις Push Είναι Απαραίτητες στις Σύγχρονες Εφαρμογές

Ας το παραδεχτούμε — οι ειδοποιήσεις push είναι ένας από τους πιο αποτελεσματικούς τρόπους να κρατήσεις τους χρήστες σου ενεργούς. Σύμφωνα με πρόσφατες μελέτες, οι εφαρμογές που αξιοποιούν στρατηγικά τα push notifications βλέπουν αύξηση retention rate έως και 20%. Αυτό δεν είναι αμελητέο.

Στο .NET MAUI 10, η υλοποίηση ειδοποιήσεων γίνεται πιο ευέλικτη χάρη στο ενοποιημένο cross-platform μοντέλο. Φυσικά, εξακολουθεί να χρειάζεται ρύθμιση ανά πλατφόρμα (κάτι που δύσκολα θα αποφύγεις πλήρως σε mobile development).

Σε αυτόν τον οδηγό θα καλύψουμε τρεις βασικές προσεγγίσεις: τοπικές ειδοποιήσεις χωρίς backend, push notifications μέσω Firebase Cloud Messaging και Apple Push Notification Service, καθώς και production-ready αρχιτεκτονική μέσω Azure Notification Hubs. Κάθε ενότητα περιέχει πλήρη παραδείγματα κώδικα — οπότε πάμε να δούμε τι παίζει.

Τοπικές Ειδοποιήσεις: Η Πιο Απλή Προσέγγιση

Οι τοπικές ειδοποιήσεις δημιουργούνται και εμφανίζονται από την ίδια τη συσκευή χωρίς εξωτερικό server. Ειλικρινά, αν χρειάζεστε απλά υπενθυμίσεις, alarms ή task reminders, αυτή είναι η πιο εύκολη λύση για να ξεκινήσετε.

Χρήση του Plugin.LocalNotification

Η πιο δημοφιλής λύση είναι το Plugin.LocalNotification (έκδοση 13.x), που παρέχει ένα ενιαίο API για Android και iOS. Η εγκατάσταση είναι straightforward:

dotnet add package Plugin.LocalNotification --version 13.0.0

Ρύθμιση στο MauiProgram.cs

Πρώτα διαμορφώνουμε το plugin στο startup. Εδώ ορίζουμε notification channels για Android — κάτι υποχρεωτικό από API 26 και μετά:

using Plugin.LocalNotification;

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .UseLocalNotification(config =>
            {
                config.AddAndroid(android =>
                {
                    android.AddChannel(new NotificationChannelRequest
                    {
                        Id = "general",
                        Name = "Γενικές Ειδοποιήσεις",
                        Description = "Γενικές ειδοποιήσεις εφαρμογής",
                        Importance = Android.App.NotificationImportance.High
                    });
                    android.AddChannel(new NotificationChannelRequest
                    {
                        Id = "reminders",
                        Name = "Υπενθυμίσεις",
                        Description = "Ειδοποιήσεις υπενθυμίσεων",
                        Importance = Android.App.NotificationImportance.Default
                    });
                });
            });

        return builder.Build();
    }
}

Android Permissions

Στο Android, χρειάζεται να δηλώσουμε τα απαιτούμενα δικαιώματα. Προσθέστε τα παρακάτω στο Platforms/Android/MainApplication.cs ή σε ξεχωριστό αρχείο:

[assembly: UsesPermission(Android.Manifest.Permission.PostNotifications)]
[assembly: UsesPermission(Android.Manifest.Permission.Vibrate)]
[assembly: UsesPermission(Android.Manifest.Permission.WakeLock)]
[assembly: UsesPermission(Android.Manifest.Permission.ReceiveBootCompleted)]
// Για ακριβή χρονοπρογραμματισμό σε Android 14+
[assembly: UsesPermission("android.permission.SCHEDULE_EXACT_ALARM")]

Αποστολή Τοπικής Ειδοποίησης

Τώρα ήρθε η ώρα να στείλουμε μια ειδοποίηση. Μπορείτε να το κάνετε είτε άμεσα είτε προγραμματισμένα — το plugin υποστηρίζει dependency injection μέσω του INotificationService, οπότε η ενσωμάτωση σε MVVM architecture είναι πολύ φυσική:

public class ReminderViewModel : ObservableObject
{
    private readonly INotificationService _notificationService;

    public ReminderViewModel(INotificationService notificationService)
    {
        _notificationService = notificationService;
    }

    [RelayCommand]
    private async Task SendImmediateNotification()
    {
        var request = new NotificationRequest
        {
            NotificationId = 1001,
            Title = "Νέο Μήνυμα",
            Description = "Έχετε ένα νέο μήνυμα στην εφαρμογή.",
            CategoryType = NotificationCategoryType.Status,
            Android = new AndroidOptions
            {
                ChannelId = "general",
                Priority = AndroidPriority.High
            }
        };
        await _notificationService.Show(request);
    }

    [RelayCommand]
    private async Task ScheduleNotification()
    {
        var request = new NotificationRequest
        {
            NotificationId = 1002,
            Title = "Υπενθύμιση",
            Description = "Η συνάντησή σας ξεκινά σε 15 λεπτά.",
            Schedule = new NotificationRequestSchedule
            {
                NotifyTime = DateTime.Now.AddMinutes(15),
                RepeatType = NotificationRepeat.No
            },
            Android = new AndroidOptions
            {
                ChannelId = "reminders"
            }
        };
        await _notificationService.Show(request);
    }
}

Χειρισμός Tap σε Ειδοποίηση

Ένα πράγμα που πολλοί ξεχνάνε: πρέπει να χειριστείτε τι γίνεται όταν ο χρήστης πατήσει την ειδοποίηση. Χωρίς αυτό, η εμπειρία μοιάζει ημιτελής.

// Στο App.xaml.cs ή σε initialization service
LocalNotificationCenter.Current.NotificationActionTapped += (sender, args) =>
{
    var notificationId = args.Request.NotificationId;
    // Πλοήγηση στη σχετική σελίδα
    Shell.Current.GoToAsync($"//details?id={notificationId}");
};

Firebase Cloud Messaging (FCM) για Android

Το Firebase Cloud Messaging είναι η πιο διαδεδομένη λύση για remote push notifications στο Android. Στο .NET MAUI 10, η ενσωμάτωση γίνεται μέσω του Plugin.FirebasePushNotifications ή χειροκίνητα μέσω native bindings — εγώ προσωπικά προτιμώ το plugin γιατί γλιτώνεις αρκετό boilerplate.

Βήμα 1: Δημιουργία Firebase Project

1. Μεταβείτε στο Firebase Console και δημιουργήστε νέο project
2. Προσθέστε την Android εφαρμογή σας χρησιμοποιώντας το ApplicationId από το .csproj
3. Κατεβάστε το αρχείο google-services.json
4. Τοποθετήστε το στο Platforms/Android/ και ορίστε Build Action σε GoogleServicesJson

Βήμα 2: Εγκατάσταση NuGet Packages

dotnet add package Plugin.FirebasePushNotifications --version 4.0.0
dotnet add package Xamarin.GooglePlayServices.Base

Βήμα 3: Ρύθμιση στο MauiProgram.cs

using Plugin.FirebasePushNotifications;

public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .UseFirebasePushNotifications(options =>
        {
            options.AutoRegistration = true;
        });

    // Εγγραφή υπηρεσιών
    builder.Services.AddSingleton<IFirebasePushNotification>(
        CrossFirebasePushNotification.Current);

    return builder.Build();
}

Βήμα 4: Υλοποίηση FirebaseMessagingService

Στο Android χρειάζεται να φτιάξουμε ένα custom FirebaseMessagingService. Αυτό αναλαμβάνει τα εισερχόμενα μηνύματα όταν η εφαρμογή βρίσκεται σε foreground — και πιστέψτε με, θα χρειαστείτε αυτό το κομμάτι περισσότερο απ΄ ό,τι νομίζετε:

// Platforms/Android/Services/MyFirebaseMessagingService.cs
using Android.App;
using Firebase.Messaging;

namespace MyApp.Platforms.Android.Services;

[Service(Exported = true)]
[IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]
public class MyFirebaseMessagingService : FirebaseMessagingService
{
    public override void OnMessageReceived(RemoteMessage message)
    {
        base.OnMessageReceived(message);

        var notification = message.GetNotification();
        if (notification != null)
        {
            SendLocalNotification(notification.Title, notification.Body);
        }
    }

    public override void OnNewToken(string token)
    {
        base.OnNewToken(token);
        // Αποστολή του token στο backend σας
        System.Diagnostics.Debug.WriteLine($"FCM Token: {token}");
    }

    private void SendLocalNotification(string title, string body)
    {
        var channelId = "firebase_default";
        var notificationBuilder = new Notification.Builder(this, channelId)
            .SetContentTitle(title)
            .SetContentText(body)
            .SetSmallIcon(Resource.Drawable.notification_icon)
            .SetAutoCancel(true);

        var notificationManager = NotificationManager.FromContext(this);
        notificationManager?.Notify(0, notificationBuilder.Build());
    }
}

Βήμα 5: Λήψη και Διαχείριση Token

Το FCM token είναι μοναδικό ανά συσκευή. Χωρίς αυτό, δεν μπορείτε να στείλετε στοχευμένες ειδοποιήσεις. Ας φτιάξουμε ένα service για τη διαχείρισή του:

public class PushNotificationService : IPushNotificationService
{
    private readonly IFirebasePushNotification _firebase;
    private readonly IHttpClientFactory _httpClientFactory;

    public PushNotificationService(
        IFirebasePushNotification firebase,
        IHttpClientFactory httpClientFactory)
    {
        _firebase = firebase;
        _httpClientFactory = httpClientFactory;
    }

    public async Task RegisterDeviceAsync()
    {
        var token = await _firebase.GetTokenAsync();
        if (!string.IsNullOrEmpty(token))
        {
            var client = _httpClientFactory.CreateClient("Api");
            await client.PostAsJsonAsync("api/devices/register", new
            {
                Token = token,
                Platform = DeviceInfo.Platform.ToString(),
                DeviceId = DeviceInfo.Current.Idiom.ToString()
            });
        }
    }

    public void SubscribeToTopic(string topic)
    {
        _firebase.Subscribe(topic);
    }
}

Apple Push Notification Service (APNS) για iOS

Εδώ τα πράγματα γίνονται λίγο πιο σύνθετα. Η Apple έχει τις δικές της απαιτήσεις για provisioning και certification, κι αν είναι η πρώτη φορά που το κάνετε, μπορεί να χρειαστεί υπομονή.

Βήμα 1: Ρύθμιση Apple Developer Account

1. Μεταβείτε στο Apple Developer Portal → Certificates, Identifiers & Profiles
2. Ενεργοποιήστε το Push Notifications capability στο App ID σας
3. Δημιουργήστε ένα APNs Authentication Key (.p8) από την ενότητα Keys
4. Σημειώστε το Key ID και το Team ID — θα τα χρειαστείτε σίγουρα αργότερα

Βήμα 2: Entitlements και Info.plist

Προσθέστε το αρχείο Entitlements.plist στο Platforms/iOS/:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>aps-environment</key>
    <string>development</string>
</dict>
</plist>

Βήμα 3: Εγγραφή για Push Notifications στο iOS

Το AppDelegate είναι το σημείο όπου ζητάμε άδεια και καταχωρούμε τη συσκευή. Ο κώδικας μπορεί να φαίνεται μεγάλος, αλλά κάθε κομμάτι έχει τον ρόλο του:

// Platforms/iOS/AppDelegate.cs
using UserNotifications;
using UIKit;

[Register("AppDelegate")]
public class AppDelegate : MauiUIApplicationDelegate
{
    protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();

    public override bool FinishedLaunching(
        UIApplication application,
        NSDictionary launchOptions)
    {
        var result = base.FinishedLaunching(application, launchOptions);

        // Αίτημα άδειας ειδοποιήσεων
        UNUserNotificationCenter.Current.RequestAuthorization(
            UNAuthorizationOptions.Alert |
            UNAuthorizationOptions.Badge |
            UNAuthorizationOptions.Sound,
            (granted, error) =>
            {
                if (granted)
                {
                    InvokeOnMainThread(() =>
                    {
                        UIApplication.SharedApplication
                            .RegisterForRemoteNotifications();
                    });
                }
            });

        UNUserNotificationCenter.Current.Delegate =
            new NotificationDelegate();

        return result;
    }

    public override void RegisteredForRemoteNotifications(
        UIApplication application,
        NSData deviceToken)
    {
        // Μετατροπή token σε string και αποστολή στο backend
        var token = BitConverter.ToString(
            deviceToken.ToArray()).Replace("-", "");
        System.Diagnostics.Debug.WriteLine($"APNS Token: {token}");
    }
}

public class NotificationDelegate : UNUserNotificationCenterDelegate
{
    public override void WillPresentNotification(
        UNUserNotificationCenter center,
        UNNotification notification,
        Action<UNNotificationPresentationOptions> completionHandler)
    {
        // Εμφάνιση ειδοποίησης ακόμα και σε foreground
        completionHandler(
            UNNotificationPresentationOptions.Banner |
            UNNotificationPresentationOptions.Sound);
    }
}

Azure Notification Hubs: Production-Ready Αρχιτεκτονική

Για εφαρμογές που πάνε σε production — και ειδικά αν μιλάμε για enterprise scale — το Azure Notification Hubs είναι η λύση που αξίζει να εξετάσετε σοβαρά. Αντί η εφαρμογή να μιλάει απευθείας με FCM και APNS, βάζετε ένα backend service στη μέση που χρησιμοποιεί το Azure ως ενδιάμεσο.

Αρχιτεκτονικό Μοντέλο

Η συνιστώμενη αρχιτεκτονική χωρίζεται σε τρία επίπεδα:

• .NET MAUI Client: Εγγράφεται στο platform notification service και στέλνει το token στο backend
• ASP.NET Core Backend: Διαχειρίζεται device registrations και στέλνει notifications μέσω Azure SDK
• Azure Notification Hub: Δρομολογεί τα μηνύματα στο σωστό platform service (FCM, APNS, WNS)

Αυτός ο διαχωρισμός μπορεί να φαίνεται υπερβολικός σε μικρά projects, αλλά σε μεγαλύτερα κλιμακώνεται εξαιρετικά.

Backend Service Implementation

// Backend ASP.NET Core API
using Microsoft.Azure.NotificationHubs;

public class NotificationHubService : INotificationHubService
{
    private readonly NotificationHubClient _hub;

    public NotificationHubService(IConfiguration config)
    {
        _hub = NotificationHubClient.CreateClientFromConnectionString(
            config["NotificationHub:ConnectionString"],
            config["NotificationHub:Name"]);
    }

    public async Task<bool> RegisterDeviceAsync(
        DeviceInstallation installation)
    {
        var azureInstallation = new Installation
        {
            InstallationId = installation.InstallationId,
            PushChannel = installation.PushChannel,
            Platform = installation.Platform switch
            {
                "Android" => NotificationPlatform.FcmV1,
                "iOS" => NotificationPlatform.Apns,
                _ => throw new ArgumentException("Unsupported platform")
            },
            Tags = installation.Tags?.ToList()
        };

        await _hub.CreateOrUpdateInstallationAsync(azureInstallation);
        return true;
    }

    public async Task SendNotificationAsync(
        string message,
        string tag = null)
    {
        // Αποστολή σε Android (FCM v1)
        var fcmPayload = $@"{{
            ""message"": {{
                ""notification"": {{
                    ""title"": ""Νέα Ειδοποίηση"",
                    ""body"": ""{message}""
                }}
            }}
        }}";

        // Αποστολή σε iOS (APNS)
        var apnsPayload = $@"{{
            ""aps"": {{
                ""alert"": {{
                    ""title"": ""Νέα Ειδοποίηση"",
                    ""body"": ""{message}""
                }},
                ""sound"": ""default""
            }}
        }}";

        if (string.IsNullOrEmpty(tag))
        {
            await Task.WhenAll(
                _hub.SendFcmV1NativeNotificationAsync(fcmPayload),
                _hub.SendAppleNativeNotificationAsync(apnsPayload));
        }
        else
        {
            await Task.WhenAll(
                _hub.SendFcmV1NativeNotificationAsync(fcmPayload, tag),
                _hub.SendAppleNativeNotificationAsync(apnsPayload, tag));
        }
    }
}

Cross-Platform Device Registration Service

Στον .NET MAUI client, φτιάχνουμε ένα ενοποιημένο service εγγραφής. Η ιδέα είναι απλή: ανεξαρτήτως πλατφόρμας, η εγγραφή γίνεται με τον ίδιο τρόπο.

public interface IDeviceInstallationService
{
    string GetDeviceId();
    DeviceInstallation GetDeviceInstallation(string token);
}

public class DeviceRegistrationService
{
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly IDeviceInstallationService _installationService;

    public DeviceRegistrationService(
        IHttpClientFactory httpClientFactory,
        IDeviceInstallationService installationService)
    {
        _httpClientFactory = httpClientFactory;
        _installationService = installationService;
    }

    public async Task RegisterWithHubAsync(string pushToken)
    {
        var installation = _installationService
            .GetDeviceInstallation(pushToken);

        var client = _httpClientFactory.CreateClient("Backend");
        var response = await client.PutAsJsonAsync(
            "api/notifications/installations", installation);

        response.EnsureSuccessStatusCode();
    }
}

Στρατηγικές Χειρισμού Ειδοποιήσεων στο .NET MAUI

Ανεξάρτητα από την υποδομή που επιλέξατε, ο τρόπος που χειρίζεστε τις ειδοποιήσεις μέσα στην εφαρμογή κάνει τεράστια διαφορά στο user experience. Ας δούμε τα βασικά.

Foreground vs Background Notifications

Η συμπεριφορά μιας ειδοποίησης αλλάζει ανάλογα με την κατάσταση της εφαρμογής:

• Foreground: Η εφαρμογή είναι ενεργή. Εδώ πρέπει να αποφασίσετε — θα δείξετε banner, in-app notification ή θα ενημερώσετε σιωπηλά τα δεδομένα;
• Background: Η εφαρμογή τρέχει αλλά δεν φαίνεται. Το OS αναλαμβάνει αυτόματα
• Terminated: Η εφαρμογή δεν τρέχει καθόλου. Το tap στην ειδοποίηση την εκκινεί με launch data

Centralized Notification Handler

Κάτι που βοηθάει πολύ στην οργάνωση είναι ένα κεντρικό handler που αποφασίζει τι γίνεται ανάλογα με τον τύπο ειδοποίησης:

public class NotificationHandler : INotificationHandler
{
    private readonly INavigationService _navigation;
    private readonly IMessenger _messenger;

    public NotificationHandler(
        INavigationService navigation,
        IMessenger messenger)
    {
        _navigation = navigation;
        _messenger = messenger;
    }

    public async Task HandleNotificationTapped(
        NotificationData data)
    {
        switch (data.Type)
        {
            case "message":
                await _navigation.GoToAsync(
                    $"///messages/detail?id={data.EntityId}");
                break;
            case "order_update":
                await _navigation.GoToAsync(
                    $"///orders/detail?id={data.EntityId}");
                break;
            default:
                await _navigation.GoToAsync("///notifications");
                break;
        }
    }

    public void HandleSilentNotification(NotificationData data)
    {
        // Ενημέρωση τοπικών δεδομένων χωρίς UI notification
        _messenger.Send(new DataRefreshMessage(data.EntityType));
    }
}

Βέλτιστες Πρακτικές και Συμβουλές

1. Ζητήστε Άδεια στη Σωστή Στιγμή

Αυτό είναι κάτι που πολλοί developers κάνουν λάθος. Μην ζητάτε άδεια ειδοποιήσεων αμέσως στην εκκίνηση — εξηγήστε πρώτα στον χρήστη γιατί τις χρειάζεστε. Στο Android 13+ και iOS, η runtime permission είναι υποχρεωτική:

public async Task<bool> RequestNotificationPermissionAsync()
{
    var status = await Permissions
        .CheckStatusAsync<Permissions.PostNotifications>();

    if (status != PermissionStatus.Granted)
    {
        status = await Permissions
            .RequestAsync<Permissions.PostNotifications>();
    }

    return status == PermissionStatus.Granted;
}

2. Χρησιμοποιήστε Notification Channels στο Android

Από το Android 8 (API 26), τα notification channels είναι υποχρεωτικά. Φτιάξτε ξεχωριστά channels ανά κατηγορία ειδοποίησης. Οι χρήστες εκτιμούν τη δυνατότητα να ελέγχουν ακριβώς τι λαμβάνουν.

3. Αποθηκεύστε το Token με Ασφάλεια

Το FCM/APNS token δεν είναι μόνιμο — αλλάζει περιστασιακά. Χρησιμοποιήστε SecureStorage για ασφαλή αποθήκευση και ενημερώστε το backend κάθε φορά:

public async Task UpdateTokenAsync(string newToken)
{
    var storedToken = await SecureStorage.Default
        .GetAsync("push_token");

    if (storedToken != newToken)
    {
        await SecureStorage.Default.SetAsync("push_token", newToken);
        await _registrationService.RegisterWithHubAsync(newToken);
    }
}

4. Debugging Tips

Αυτά τα tips θα σας γλιτώσουν χρόνο (μιλάω από εμπειρία):

• Στο iOS, οι push notifications λειτουργούν μόνο σε φυσικές συσκευές ή iOS Simulator 16+ σε Mac με Apple Silicon
• Στο Android, ελέγξτε ότι το google-services.json έχει σωστό Build Action — αυτό είναι η νούμερο ένα αιτία σφαλμάτων
• Κάντε re-register σε κάθε debug session. Ο debugger μπορεί να δημιουργήσει νέο token χωρίς να το καταλάβετε
• Χρησιμοποιήστε τα test send features στα Firebase Console και Azure Portal για τα πρώτα σας tests

Συχνές Ερωτήσεις (FAQ)

Ποια είναι η διαφορά μεταξύ τοπικών και push notifications στο .NET MAUI;

Οι τοπικές ειδοποιήσεις δημιουργούνται εξ ολοκλήρου στη συσκευή, χωρίς εξωτερικό server. Ιδανικές για υπενθυμίσεις ή προγραμματισμένα events. Οι push notifications, από την άλλη, αποστέλλονται από απομακρυσμένο server μέσω FCM ή APNS και χρησιμοποιούνται για real-time ενημερώσεις, μηνύματα ή marketing.

Χρειάζομαι Azure Notification Hubs ή αρκεί μόνο το Firebase;

Εξαρτάται. Το Firebase Cloud Messaging καλύπτει τόσο Android όσο και iOS, οπότε για μικρές ως μεσαίες εφαρμογές συνήθως αρκεί. Αλλά αν χρειάζεστε tag-based routing, scheduled notifications, telemetry, και ενοποιημένη διαχείριση σε enterprise scale, τότε το Azure Notification Hubs αξίζει τον κόπο.

Γιατί δεν λαμβάνω push notifications στο iOS simulator;

Αν τρέχετε σε Mac χωρίς Apple Silicon ή σε παλαιότερη έκδοση macOS (πριν το 13), αυτό είναι αναμενόμενο. Οι push notifications στο simulator υποστηρίζονται μόνο σε iOS 16+ σε macOS 13+ σε Apple Silicon ή T2. Σε κάθε άλλη περίπτωση, χρειάζεστε φυσική συσκευή ή TestFlight.

Πώς μπορώ να στείλω ειδοποιήσεις σε συγκεκριμένους χρήστες;

Χρησιμοποιήστε tag-based targeting. Κατά την εγγραφή, προσθέστε tags όπως user:12345 ή topic:news, και στη συνέχεια στοχεύστε αυτά τα tags κατά την αποστολή. Δουλεύει τόσο με Firebase topics όσο και με Azure Notification Hubs tags.

Πώς χειρίζομαι τις ειδοποιήσεις όταν η εφαρμογή είναι κλειστή;

Όταν η εφαρμογή δεν τρέχει, το OS εμφανίζει αυτόματα την ειδοποίηση. Το ενδιαφέρον μέρος είναι τι γίνεται μετά: όταν ο χρήστης πατήσει πάνω της, η εφαρμογή εκκινεί με launch data. Στο Android αυτά φτάνουν μέσω Intent.Extras, στο iOS μέσω launchOptions. Επεξεργαστείτε τα στο startup για σωστή πλοήγηση.