Lokale Benachrichtigungen

Beispiel durchsuchen.Durchsuchen Sie das Beispiel

Lokale Benachrichtigungen werden von Apps gesendet, die auf einem Gerät installiert sind. Lokale Benachrichtigungen werden häufig für Funktionen wie die folgenden verwendet:

• Kalenderereignisse
• Erinnerungen
• Standortbasierte Auslöser

Jede Plattform erfordert eine eigene Implementierung von nativem Code zum Senden und Empfangen lokaler Benachrichtigungen. Jede Plattformimplementierung kann jedoch auf plattformübergreifender Ebene abstrahiert werden, sodass eine konsistente API zum Senden und Empfangen lokaler Benachrichtigungen in einer .NET MAUI-App (.NET Multi-Platform App UI) vorhanden ist.

Erstellen einer plattformübergreifenden Abstraktion

Eine .NET MAUI-App sollte lokale Benachrichtigungen senden und empfangen, ohne die zugrunde liegenden Plattformimplementierungen zu beachten. Die folgende INotificationManagerService-Schnittstelle wird verwendet, um eine plattformübergreifende API zu definieren, die für die Interaktion mit lokalen Benachrichtigungen verwendet werden kann:

public interface INotificationManagerService
{
    event EventHandler NotificationReceived;
    void SendNotification(string title, string message, DateTime? notifyTime = null);
    void ReceiveNotification(string title, string message);
}

Diese Schnittstelle definiert die folgenden Vorgänge:

• Mit dem Ereignis NotificationReceived kann eine App eingehende Benachrichtigungen behandeln.
• Die SendNotification-Methode sendet eine Benachrichtigung an eine optionale DateTime.
• Die ReceiveNotification-Methode verarbeitet eine Benachrichtigung beim Empfang durch die zugrunde liegende Plattform.

Die Schnittstelle sollte auf jeder Plattform implementiert werden, die lokale Benachrichtigungen unterstützen soll.

Implementieren lokaler Benachrichtigungen unter Android

Bei Android ist eine lokale Benachrichtigung eine Meldung, die außerhalb der Benutzeroberfläche Ihrer App angezeigt wird, um Erinnerungen oder andere Informationen aus der App bereitzustellen. Benutzer können auf die Benachrichtigung tippen, um die App zu öffnen, oder optional eine Aktion direkt über die Benachrichtigung ausführen. Informationen zu lokalen Benachrichtigungen unter Android finden Sie unter Notifications overview (Übersicht über Benachrichtigungen) auf developer.android.com.

Damit eine .NET MAUI-App Benachrichtigungen unter Android senden und empfangen kann, muss die App eine Implementierung der INotificationManagerService-Schnittstelle bereitstellen.

Senden und Empfangen lokaler Benachrichtigungen

Unter Android implementiert die NotificationManagerService-Klasse die INotificationManagerService-Schnittstelle und enthält die Logik zum Senden und Empfangen lokaler Benachrichtigungen:

using Android.App;
using Android.Content;
using Android.Graphics;
using Android.OS;
using AndroidX.Core.App;

namespace LocalNotificationsDemo.Platforms.Android;

public class NotificationManagerService : INotificationManagerService
{
    const string channelId = "default";
    const string channelName = "Default";
    const string channelDescription = "The default channel for notifications.";

    public const string TitleKey = "title";
    public const string MessageKey = "message";

    bool channelInitialized = false;
    int messageId = 0;
    int pendingIntentId = 0;

    NotificationManagerCompat compatManager;

    public event EventHandler NotificationReceived;

    public static NotificationManagerService Instance { get; private set; }

    public NotificationManagerService()
    {
        if (Instance == null)
        {
            CreateNotificationChannel();
            compatManager = NotificationManagerCompat.From(Platform.AppContext);
            Instance = this;
        }
    }

    public void SendNotification(string title, string message, DateTime? notifyTime = null)
    {
        if (!channelInitialized)
        {
            CreateNotificationChannel();
        }

        if (notifyTime != null)
        {
            Intent intent = new Intent(Platform.AppContext, typeof(AlarmHandler));
            intent.PutExtra(TitleKey, title);
            intent.PutExtra(MessageKey, message);
            intent.SetFlags(ActivityFlags.SingleTop | ActivityFlags.ClearTop);

            var pendingIntentFlags = (Build.VERSION.SdkInt >= BuildVersionCodes.S)
                ? PendingIntentFlags.CancelCurrent | PendingIntentFlags.Immutable
                : PendingIntentFlags.CancelCurrent;

            PendingIntent pendingIntent = PendingIntent.GetBroadcast(Platform.AppContext, pendingIntentId++, intent, pendingIntentFlags);
            long triggerTime = GetNotifyTime(notifyTime.Value);
            AlarmManager alarmManager = Platform.AppContext.GetSystemService(Context.AlarmService) as AlarmManager;
            alarmManager.Set(AlarmType.RtcWakeup, triggerTime, pendingIntent);
        }
        else
        {
            Show(title, message);
        }
    }

    public void ReceiveNotification(string title, string message)
    {
        var args = new NotificationEventArgs()
        {
            Title = title,
            Message = message,
        };
        NotificationReceived?.Invoke(null, args);
    }

    public void Show(string title, string message)
    {
        Intent intent = new Intent(Platform.AppContext, typeof(MainActivity));
        intent.PutExtra(TitleKey, title);
        intent.PutExtra(MessageKey, message);
        intent.SetFlags(ActivityFlags.SingleTop | ActivityFlags.ClearTop);

        var pendingIntentFlags = (Build.VERSION.SdkInt >= BuildVersionCodes.S)
            ? PendingIntentFlags.UpdateCurrent | PendingIntentFlags.Immutable
            : PendingIntentFlags.UpdateCurrent;

        PendingIntent pendingIntent = PendingIntent.GetActivity(Platform.AppContext, pendingIntentId++, intent, pendingIntentFlags);
        NotificationCompat.Builder builder = new NotificationCompat.Builder(Platform.AppContext, channelId)
            .SetContentIntent(pendingIntent)
            .SetContentTitle(title)
            .SetContentText(message)
            .SetLargeIcon(BitmapFactory.DecodeResource(Platform.AppContext.Resources, Resource.Drawable.dotnet_logo))
            .SetSmallIcon(Resource.Drawable.message_small);

        Notification notification = builder.Build();
        compatManager.Notify(messageId++, notification);  
    }

    void CreateNotificationChannel()
    {
        // Create the notification channel, but only on API 26+.
        if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
        {
            var channelNameJava = new Java.Lang.String(channelName);
            var channel = new NotificationChannel(channelId, channelNameJava, NotificationImportance.Default)
            {
                Description = channelDescription
            };
            // Register the channel
            NotificationManager manager = (NotificationManager)Platform.AppContext.GetSystemService(Context.NotificationService);
            manager.CreateNotificationChannel(channel);
            channelInitialized = true;
        }
    }

    long GetNotifyTime(DateTime notifyTime)
    {
        DateTime utcTime = TimeZoneInfo.ConvertTimeToUtc(notifyTime);
        double epochDiff = (new DateTime(1970, 1, 1) - DateTime.MinValue).TotalSeconds;
        long utcAlarmTime = utcTime.AddSeconds(-epochDiff).Ticks / 10000;
        return utcAlarmTime; // milliseconds
    }
}

Die NotificationManagerService-Klasse sollte im Ordner Plattformen > Android Ihrer App platziert werden. Alternativ können mehrere Ziele basierend auf Ihren eigenen Dateinamens- und Ordnerkriterien angezielt werden, anstatt den Ordner Plattformen > Android zu verwenden. Weitere Informationen finden Sie unter Konfigurieren von Multi-Targeting.

Android ermöglicht Apps das Definieren mehrerer Kanäle für Benachrichtigungen. Der Konstruktor NotificationManagerService erstellt einen einfachen Kanal, der zum Senden von Benachrichtigungen verwendet wird. Die SendNotification-Methode definiert die plattformspezifische Logik, die erforderlich ist, um eine Benachrichtigung zu erstellen und zu senden. Die ReceiveNotification-Methode wird vom Android-Betriebssystem aufgerufen, wenn eine Nachricht empfangen wird, und ruft den Ereignishandler NotificationReceived auf. Weitere Informationen finden Sie unter Create a notification (Erstellen einer Benachrichtigung) auf developer.android.com.

Die SendNotification-Methode erstellt sofort oder zu einem exakten Zeitpunkt (DateTime) eine lokale Benachrichtigung. Mithilfe der AlarmManager-Klasse kann eine Benachrichtigung für einen exakten Zeitpunkt (DateTime) geplant werden. Die Benachrichtigung wird durch ein Objekt empfangen, das von der BroadcastReceiver-Klasse abgeleitet wird:

[BroadcastReceiver(Enabled = true, Label = "Local Notifications Broadcast Receiver")]
public class AlarmHandler : BroadcastReceiver
{
    public override void OnReceive(Context context, Intent intent)
    {
        if (intent?.Extras != null)
        {
            string title = intent.GetStringExtra(NotificationManagerService.TitleKey);
            string message = intent.GetStringExtra(NotificationManagerService.MessageKey);

            NotificationManagerService manager = NotificationManagerService.Instance ?? new NotificationManagerService();
            manager.Show(title, message);
        }
    }
}

Wichtig

Standardmäßig bleiben Benachrichtigungen, die mithilfe der AlarmManager-Klasse geplant werden, nicht über den Geräteneustart hinaus erhalten. Sie können Ihre App jedoch so entwerfen, dass Benachrichtigungen automatisch neu geplant werden, wenn das Gerät neu gestartet wird. Weitere Informationen finden Sie auf developer.android.com im Leitfaden Schedule repeating alarms (Planen von wiederholten Alarmen) im Abschnitt Start an alarm when the device restarts (Starten eines Alarms bei Neustart eines Geräts). Informationen zur Hintergrundverarbeitung unter Android finden Sie auf developer.android.com im Guide to background processing (Leitfaden zur Hintergrundverarbeitung).

Behandeln eingehender Benachrichtigungen

Die Android-App muss eingehende Benachrichtigungen erkennen und die NotificationManagerService-Instanz benachrichtigen. Eine Möglichkeit, dies zu erreichen, besteht darin, die MainActivity-Klasse zu ändern.

Das Activity-Attribut der MainActivity-Klasse sollte einen LaunchMode-Wert von LaunchMode.SingleTop angeben:

[Activity(Theme = "@style/Maui.SplashTheme", MainLauncher = true, LaunchMode = LaunchMode.SingleTop, //... )]
public class MainActivity : MauiAppCompatActivity
{
}

Der SingleTop-Modus verhindert, dass mehrere Instanzen einer Activity gestartet werden, während sich die App im Vordergrund befindet. Dieser LaunchMode eignet sich möglicherweise nicht für Apps, die mehrere Aktivitäten in komplexeren Benachrichtigungsszenarien starten. Weitere Informationen zu LaunchMode-Enumerationswerten finden Sie unter Android Activity LaunchMode auf developer.android.com.

Die MainActivity-Klasse muss auch geändert werden, um eingehende Benachrichtigungen zu empfangen:

public class MainActivity : MauiAppCompatActivity
{
    protected override void OnCreate(Bundle? savedInstanceState)
    {
        base.OnCreate(savedInstanceState);

        CreateNotificationFromIntent(Intent);
    }

    protected override void OnNewIntent(Intent? intent)
    {
        base.OnNewIntent(intent);

        CreateNotificationFromIntent(intent);
    }

    static void CreateNotificationFromIntent(Intent intent)
    {
        if (intent?.Extras != null)
        {
            string title = intent.GetStringExtra(LocalNotificationsDemo.Platforms.Android.NotificationManagerService.TitleKey);
            string message = intent.GetStringExtra(LocalNotificationsDemo.Platforms.Android.NotificationManagerService.MessageKey);

            var service = IPlatformApplication.Current.Services.GetService<INotificationManagerService>();
            service.ReceiveNotification(title, message);
        }
    }
}

Die CreateNotificationFromIntent-Methode extrahiert Benachrichtigungsdaten aus dem Argument intent und übergibt sie an die ReceiveNotification-Methode in der Klasse NotificationManagerService. Die CreateNotificationFromIntent-Methode wird sowohl von der OnCreate-Methode als auch der OnNewIntent-Methode aufgerufen:

• Wenn die App durch Benachrichtigungsdaten gestartet wird, werden die Intent-Daten an die OnCreate-Methode übergeben.
• Wenn sich die App bereits im Vordergrund befindet, werden die Intent-Daten an die OnNewIntent-Methode übergeben.

Überprüfen der Berechtigung

Android 13 (API 33) und höher erfordert die Berechtigung POST_NOTIFICATIONS zum Senden von Benachrichtigungen aus einer App. Diese Berechtigung sollte in Ihrer Datei AndroidManifest.xml deklariert werden:

<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />

Weitere Informationen zur Berechtigung POST_NOTIFICATIONS finden Sie unter Notification runtime permission (Benachrichtigungs-Laufzeitberechtigung) auf developer.android.com.

Sie sollten eine Berechtigungsklasse implementieren, die zur Laufzeit auf die Berechtigungsdeklaration überprüft:

using Android;

namespace LocalNotificationsDemo.Platforms.Android;

public class NotificationPermission : Permissions.BasePlatformPermission
{
    public override (string androidPermission, bool isRuntime)[] RequiredPermissions
    {
        get
        {
            var result = new List<(string androidPermission, bool isRuntime)>();
            if (OperatingSystem.IsAndroidVersionAtLeast(33))
                result.Add((Manifest.Permission.PostNotifications, true));
            return result.ToArray();
        }
    }
}

Nachdem die App gestartet wurde, sollten Sie den Benutzer bitten, diese Berechtigung zu erteilen, bevor Sie versuchen, eine lokale Benachrichtigung zu senden:

PermissionStatus status = await Permissions.RequestAsync<NotificationPermission>();

Weitere Informationen zu .NET MAUI-Berechtigungen finden Sie unter Berechtigungen.

Implementieren lokaler Benachrichtigungen unter iOS und Mac Catalyst

Auf Apple-Plattformen ist eine lokale Benachrichtigung eine Nachricht, die wichtige Informationen für Benutzer vermittelt. Das System stellt Benachrichtigungen basierend auf einer bestimmten Uhrzeit oder einem bestimmten Ort zu. Informationen zu lokalen Benachrichtigungen auf Apple-Plattformen finden Sie unter Scheduling a notification locally from your app (Lokales Planen einer Benachrichtigung von Ihrer App) auf developer.apple.com.

Damit eine .NET MAUI-App Benachrichtigungen auf Apple-Plattformen senden und empfangen kann, muss die App eine Implementierung der INotificationManagerService-Schnittstelle bereitstellen.

Senden und Empfangen lokaler Benachrichtigungen

Auf Apple-Plattformen implementiert die NotificationManagerService-Klasse die INotificationManagerService-Schnittstelle und enthält die Logik zum Senden und Empfangen lokaler Benachrichtigungen:

using Foundation;
using UserNotifications;

namespace LocalNotificationsDemo.Platforms.iOS;

public class NotificationManagerService : INotificationManagerService
{
    int messageId = 0;
    bool hasNotificationsPermission;

    public event EventHandler? NotificationReceived;

    public NotificationManagerService()
    {
        // Create a UNUserNotificationCenterDelegate to handle incoming messages.
        UNUserNotificationCenter.Current.Delegate = new NotificationReceiver();

        // Request permission to use local notifications.
        UNUserNotificationCenter.Current.RequestAuthorization(UNAuthorizationOptions.Alert, (approved, err) =>
        {
            hasNotificationsPermission = approved;
        });
    }

    public void SendNotification(string title, string message, DateTime? notifyTime = null)
    {
        // App doesn't have permissions.
        if (!hasNotificationsPermission)
            return;

        messageId++;
        var content = new UNMutableNotificationContent()
        {
            Title = title,
            Subtitle = "",
            Body = message,
            Badge = 1
        };

        UNNotificationTrigger trigger;
        if (notifyTime != null)
            // Create a calendar-based trigger.
            trigger = UNCalendarNotificationTrigger.CreateTrigger(GetNSDateComponents(notifyTime.Value), false);
        else
            // Create a time-based trigger, interval is in seconds and must be greater than 0.
            trigger = UNTimeIntervalNotificationTrigger.CreateTrigger(0.25, false);

        var request = UNNotificationRequest.FromIdentifier(messageId.ToString(), content, trigger);
        UNUserNotificationCenter.Current.AddNotificationRequest(request, (err) =>
        {
            if (err != null)
                throw new Exception($"Failed to schedule notification: {err}");
        });
    }

    public void ReceiveNotification(string title, string message)
    {
        var args = new NotificationEventArgs()
        {
            Title = title,
            Message = message
        };
        NotificationReceived?.Invoke(null, args);
    }

    NSDateComponents GetNSDateComponents(DateTime dateTime)
    {
        return new NSDateComponents
        {
            Month = dateTime.Month,
            Day = dateTime.Day,
            Year = dateTime.Year,
            Hour = dateTime.Hour,
            Minute = dateTime.Minute,
            Second = dateTime.Second
        };
    }
}

Die NotificationManagerService-Klasse sollte im Verzeichnis Plattformen > iOS bzw. Plattformen > Mac Catalyst Ihrer App platziert werden. Alternativ können mehrere Ziele basierend auf Ihren eigenen Dateinamens- und Ordnerkriterien angezielt werden, anstatt den Ordner Plattformen zu verwenden. Weitere Informationen finden Sie unter Konfigurieren von Multi-Targeting.

Auf Apple-Plattformen müssen Sie die Berechtigung zum Verwenden von Benachrichtigungen anfordern, bevor Sie versuchen, eine Benachrichtigung zu planen. Dies geschieht im Konstruktor NotificationManagerService. Weitere Informationen zu Berechtigungen für lokale Benachrichtigungen finden Sie unter Asking permission to use notifications (Erfragen der Berechtigung zum Verwenden von Benachrichtigungen) auf developer.apple.com.

Die SendNotification-Methode definiert die erforderliche Logik zum Erstellen und Senden einer Benachrichtigung und erstellt eine lokale Benachrichtigung sofort mithilfe eines UNTimeIntervalNotificationTrigger-Objekts oder in einer genauen DateTime mithilfe eines UNCalendarNotificationTrigger-Objekts. Die ReceiveNotification-Methode wird von iOS aufgerufen, wenn eine Nachricht empfangen wird, und ruft den Ereignishandler NotificationReceived auf.

Behandeln eingehender Benachrichtigungen

Auf Apple-Plattformen müssen Sie zum Behandeln eingehender Nachrichten einen Delegaten erstellen, der UNUserNotificationCenterDelegate als Unterklasse behandelt:

using UserNotifications;

namespace LocalNotificationsDemo.Platforms.iOS;

public class NotificationReceiver : UNUserNotificationCenterDelegate
{
    // Called if app is in the foreground.
    public override void WillPresentNotification(UNUserNotificationCenter center, UNNotification notification, Action<UNNotificationPresentationOptions> completionHandler)
    {
        ProcessNotification(notification);

        var presentationOptions = (OperatingSystem.IsIOSVersionAtLeast(14))
            ? UNNotificationPresentationOptions.Banner
            : UNNotificationPresentationOptions.Alert;

        completionHandler(presentationOptions);
    }

    // Called if app is in the background, or killed state.
    public override void DidReceiveNotificationResponse(UNUserNotificationCenter center, UNNotificationResponse response, Action completionHandler)
    {
        if (response.IsDefaultAction)
            ProcessNotification(response.Notification);

        completionHandler();
    }

    void ProcessNotification(UNNotification notification)
    {
        string title = notification.Request.Content.Title;
        string message = notification.Request.Content.Body;

        var service = IPlatformApplication.Current?.Services.GetService<INotificationManagerService>();
        service?.ReceiveNotification(title, message);
    }
}

Die NotificationReceiver-Klasse wird als Delegat UNUserNotificationCenter im Konstruktor NotificationManagerService registriert und stellt eingehende Benachrichtigungsdaten für die ReceiveNotification-Methode in der NotificationManagerService-Klasse bereit.

Implementieren lokaler Benachrichtigungen unter Windows

Lokale Benachrichtigungen im Windows-App-SDK sind Meldungen, die Ihre App an Benutzer senden kann, während sie sich derzeit nicht in Ihrer App befinden. Der Benachrichtigungsinhalt wird in einem vorübergehenden Fenster in der rechten unteren Ecke des Bildschirms und im Benachrichtigungscenter angezeigt. Lokale Benachrichtigungen können verwendet werden, um Benutzer über den App-Status zu informieren oder sie aufzufordern, eine Aktion auszuführen.

Informationen zu lokalen Benachrichtigungen unter Windows, einschließlich Implementierungsdetails für gepackte und ungepackte Apps, finden Sie unter Übersicht über App-Benachrichtigungen.

Warnung

Derzeit werden geplante Benachrichtigungen im Windows App SDK nicht unterstützt. Weitere Informationen finden Sie unter Funktionsanforderung: Toast-Benachrichtigungen planen.

Registrieren von Plattformimplementierungen

Jede NotificationManagerService-Implementierung sollte bei der INotificationManagerService-Schnittstelle registriert werden, sodass die von der Schnittstelle verfügbar gemachten Vorgänge von plattformübergreifendem Code aufgerufen werden können. Dies kann durch Registrieren der Typen mit der Services-Eigenschaft des MauiAppBuilder-Objekts in der CreateMauiApp-Methode der MauiProgram-Klasse erreicht werden:

#if ANDROID
            builder.Services.AddTransient<INotificationManagerService, LocalNotificationsDemo.Platforms.Android.NotificationManagerService>();
#elif IOS
            builder.Services.AddTransient<INotificationManagerService, LocalNotificationsDemo.Platforms.iOS.NotificationManagerService>();
#elif MACCATALYST
            builder.Services.AddTransient<INotificationManagerService, LocalNotificationsDemo.Platforms.MacCatalyst.NotificationManagerService>();
#elif WINDOWS
            builder.Services.AddTransient<INotificationManagerService, LocalNotificationsDemo.Platforms.Windows.NotificationManagerService>();          
#endif

Weitere Informationen zur Abhängigkeitsinjektion in .NET MAUI finden Sie unter Abhängigkeitsinjektion.

Senden und Empfangen lokaler Benachrichtigungen

Eine INotificationManagerService-Implementierung kann durch automatische Abhängigkeitsauflösung oder durch explizite Abhängigkeitsauflösung aufgelöst werden. Das folgende Beispiel zeigt, wie eine explizite Abhängigkeitsauflösung verwendet wird, um eine INotificationManagerService-Implementierung aufzulösen:

// Assume the app uses a single window.
INotificationManagerService notificationManager =
    Application.Current?.Windows[0].Page?.Handler?.MauiContext?.Services.GetService<INotificationManagerService>();

Weitere Informationen zum Auflösen registrierter Typen finden Sie unter Auflösung.

Nachdem die INotificationManagerService-Implementierung aufgelöst wurde, können ihre Vorgänge aufgerufen werden:

// Send
notificationManager.SendNotification();

// Scheduled send
notificationManager.SendNotification("Notification title goes here", "Notification messages goes here.", DateTime.Now.AddSeconds(10));

// Receive
notificationManager.NotificationReceived += (sender, eventArgs) =>
{
    var eventData = (NotificationEventArgs)eventArgs;

    MainThread.BeginInvokeOnMainThread(() =>
    {
        // Take required action in the app once the notification has been received.
    });
};
}

Der Ereignishandler NotificationReceived wandelt seine Ereignisargumente in NotificationEventArgs um, sodass die Eigenschaften Title und Message definiert werden:

public class NotificationEventArgs : EventArgs
{
    public string Title { get; set; }
    public string Message { get; set; }
}

Wenn unter Android eine Benachrichtigung gesendet wird, wird sie in der Statusleiste als Symbol angezeigt:

Ein Benachrichtigungssymbol in der Statusleiste von Android.

Wenn Sie auf der Statusleiste nach unten wischen, wird die Benachrichtigungsschublade geöffnet:

Eine lokale Benachrichtigung in der Benachrichtigungsschublade von Android.

Durch Tippen auf die Benachrichtigung wird die App gestartet. Eine Benachrichtigung bleibt in der Benachrichtigungsschublade sichtbar, bis sie von der App oder vom Benutzer geschlossen wird.

In iOS werden eingehende Benachrichtigungen automatisch von einer App empfangen, ohne dass Benutzereingaben erforderlich sind:

Eine Benachrichtigung unter iOS.

Unter Mac Catalyst werden eingehende Benachrichtigungen automatisch vom Mitteilungszentrum empfangen:

Eine Benachrichtigung im Mitteilungszentrum unter macOS.

Weitere Informationen zum Mitteilungszentrum finden Sie unter Use Notification Centre on Mac (Verwenden des Mitteilungszentrums auf dem Mac) auf support.apple.com.