Wyślij powiadomienie kafelka lokalnego

Podstawowe kafelki aplikacji w systemie Windows 10 są definiowane w manifeście aplikacji, podczas gdy kafelki pomocnicze są programowo tworzone i definiowane przez kod aplikacji. W tym artykule opisano sposób wysyłania lokalnego powiadomienia kafelka do podstawowego kafelka i drugorzędnego kafelka przy użyciu szablonów kafelków adaptacyjnych. Powiadomienie lokalne to takie, które jest wysyłane z kodu aplikacji, a nie wypychane lub ściągane z serwera internetowego.

Instalowanie pakietu NuGet

Zalecamy zainstalowanie pakietu NuGet biblioteki Notifications, co upraszcza proces generowania ładunków kafelków za pomocą obiektów zamiast nieprzetworzonego kodu XML.

Przykłady kodu wbudowanego w tym artykule dotyczą języka C# przy użyciu biblioteki Notifications. (Jeśli wolisz utworzyć własny kod XML, możesz znaleźć przykłady kodu bez biblioteki Notifications na końcu artykułu).

Dodaj deklaracje przestrzeni nazw

Aby uzyskać dostęp do interfejsów API kafelka, dołącz windows.UI.Notifications przestrzeni nazw. Zalecamy również dołączenie przestrzeni nazw Microsoft.Toolkit.Uwp.Notifications, aby móc korzystać z naszych API pomocniczych kafelków (należy zainstalować bibliotekę Notifications pakiet NuGet, aby uzyskać do nich dostęp).

using Windows.UI.Notifications;
using Microsoft.Toolkit.Uwp.Notifications; // Notifications library

Tworzenie zawartości powiadomienia

W systemie Windows 10 ładunki kafelków są definiowane przy użyciu szablonów kafelków adaptacyjnych, które umożliwiają tworzenie niestandardowych układów wizualizacji dla powiadomień. (Aby dowiedzieć się, co jest możliwe w przypadku kafelków adaptacyjnych, zobacz Tworzenie kafelków adaptacyjnych).

Ten przykład kodu tworzy zawartość adaptacyjnych płytek dla średnich i szerokich płytek.

// In a real app, these would be initialized with actual data
string from = "Jennifer Parker";
string subject = "Photos from our trip";
string body = "Check out these awesome photos I took while in New Zealand!";

// Construct the tile content
TileContent content = new TileContent()
{
    Visual = new TileVisual()
    {
        TileMedium = new TileBinding()
        {
            Content = new TileBindingContentAdaptive()
            {
                Children =
                {
                    new AdaptiveText()
                    {
                        Text = from
                    },

                    new AdaptiveText()
                    {
                        Text = subject,
                        HintStyle = AdaptiveTextStyle.CaptionSubtle
                    },

                    new AdaptiveText()
                    {
                        Text = body,
                        HintStyle = AdaptiveTextStyle.CaptionSubtle
                    }
                }
            }
        },

        TileWide = new TileBinding()
        {
            Content = new TileBindingContentAdaptive()
            {
                Children =
                {
                    new AdaptiveText()
                    {
                        Text = from,
                        HintStyle = AdaptiveTextStyle.Subtitle
                    },

                    new AdaptiveText()
                    {
                        Text = subject,
                        HintStyle = AdaptiveTextStyle.CaptionSubtle
                    },

                    new AdaptiveText()
                    {
                        Text = body,
                        HintStyle = AdaptiveTextStyle.CaptionSubtle
                    }
                }
            }
        }
    }
};

Zawartość powiadomienia wygląda następująco, gdy jest wyświetlana na średnim kafelku:

Tworzenie powiadomienia

Po utworzeniu zawartości powiadomienia należy utworzyć nową TileNotification. Konstruktor TileNotification przyjmuje obiekt XmlDocument środowiska uruchomieniowego Windows, który można uzyskać za pomocą metody TileContent.GetXml, jeśli korzystasz z biblioteki Notifications.

Ten przykładowy kod tworzy powiadomienie dla nowego kafelka.

// Create the tile notification
var notification = new TileNotification(content.GetXml());

Ustawianie czasu wygaśnięcia powiadomienia (opcjonalnie)

Domyślnie powiadomienia lokalne na kafelkach i z odznakami nie wygasają, natomiast powiadomienia push, okresowe i zaplanowane wygasają po trzech dniach. Ponieważ zawartość kafelka nie powinna trwać dłużej niż jest to konieczne, najlepszym rozwiązaniem jest ustawienie czasu wygaśnięcia, który ma sens dla aplikacji, zwłaszcza w przypadku powiadomień kafelków lokalnych i znaczków.

Ten przykładowy kod tworzy powiadomienie, które wygaśnie i zostanie usunięte z kafelka po dziesięciu minutach.

tileNotification.ExpirationTime = DateTimeOffset.UtcNow.AddMinutes(10);

Wysyłanie powiadomienia

Chociaż lokalne wysyłanie powiadomienia kafelka jest proste, sposób wysyłania powiadomienia do podstawowego lub pomocniczego kafelka jest nieco inny.

główna kafelka

Aby wysłać powiadomienie do kafelka podstawowego, użyj elementu TileUpdateManager , aby utworzyć aktualizator kafelków dla kafelka podstawowego i wysłać powiadomienie, wywołując polecenie "Aktualizuj". Niezależnie od tego, czy jest widoczny, główny kafelek aplikacji zawsze istnieje, więc można wysyłać do niego powiadomienia nawet wtedy, gdy nie jest przypięty. Jeśli użytkownik przypnie później główną kafelkę, powiadomienia, które wysłałeś, zostaną wyświetlone.

Ten przykładowy kod wysyła powiadomienie do kafelka podstawowego.

// Send the notification to the primary tile
TileUpdateManager.CreateTileUpdaterForApplication().Update(notification);

kafelka pomocniczego

Aby wysłać powiadomienie do kafelka podrzędnego, najpierw upewnij się, że ten kafelek istnieje. Jeśli spróbujesz utworzyć aktualizator kafelków dla pomocniczego kafelka, który nie istnieje (na przykład jeśli użytkownik odpiął pomocniczy kafelek), zostanie zgłoszony wyjątek. Możesz użyć secondaryTile.Exists(tileId), aby sprawdzić, czy pomocniczy kafelek jest przypięty, a następnie utworzyć aktualizator kafelków dla pomocniczego kafelka i wysłać powiadomienie.

Ten przykład kodu wysyła powiadomienie do sekundarnego kafelka.

// If the secondary tile is pinned
if (SecondaryTile.Exists("MySecondaryTile"))
{
    // Get its updater
    var updater = TileUpdateManager.CreateTileUpdaterForSecondaryTile("MySecondaryTile");

    // And send the notification
    updater.Update(notification);
}

Wyczyść powiadomienia na kafelku (opcjonalnie)

W większości przypadków należy wyczyścić powiadomienie po interakcji użytkownika z tej zawartości. Na przykład gdy użytkownik uruchamia aplikację, może być konieczne wyczyszczenie wszystkich powiadomień z kafelka. Jeśli powiadomienia są powiązane czasowo, zalecamy ustawienie czasu wygaśnięcia powiadomienia zamiast jawnego wyczyszczenia powiadomienia.

Ten przykład kodu usuwa powiadomienie dla głównego kafelka. Możesz to zrobić w przypadku kafelków pomocniczych, tworząc aktualizator kafelków dla pomocniczego kafelka.

TileUpdateManager.CreateTileUpdaterForApplication().Clear();

W przypadku kafelka z włączoną kolejką powiadomień i powiadomieniami w kolejce wywołanie metody Clear opróżni kolejkę. Nie można jednak wyczyścić powiadomienia za pośrednictwem serwera aplikacji; tylko lokalny kod aplikacji może wyczyścić powiadomienia.

Powiadomienia okresowe lub wypychane mogą dodawać tylko nowe powiadomienia lub zastępować istniejące powiadomienia. Lokalne wywołanie metody Clear spowoduje wyczyszczenie kafelka, niezależnie od tego, czy powiadomienia zostały dostarczone za pomocą technologii push, w sposób okresowy, czy lokalny. Zaplanowane powiadomienia, które nie zostały jeszcze wyświetlone, nie są czyszczone przez tę metodę.

kafelek

Dalsze kroki

Używanie kolejki powiadomień

Po wykonaniu pierwszej aktualizacji kafelka możesz rozszerzyć jego funkcjonalność, włączając kolejkowanie powiadomień .

Inne metody dostarczania powiadomień

W tym artykule pokazano, jak wysłać aktualizację kafelka jako powiadomienie. Aby zapoznać się z innymi metodami dostarczania powiadomień, w tym zaplanowanymi, okresowymi i push, zobacz Dostarczanie powiadomień.

XmlEncode metoda dostarczania

Jeśli nie używasz biblioteki Powiadomień, ta metoda dostarczania powiadomień jest inną alternatywą.

public string XmlEncode(string text)
{
    StringBuilder builder = new StringBuilder();
    using (var writer = XmlWriter.Create(builder))
    {
        writer.WriteString(text);
    }

    return builder.ToString();
}

Przykłady kodu bez biblioteki powiadomień

Jeśli wolisz pracować z nieprzetworzonym XML-em zamiast z pakietem NuGet biblioteki powiadomień , użyj tych alternatywnych przykładów kodu do pierwszych trzech przykładów podanych w tym artykule. Pozostałe przykłady kodu mogą być używane z biblioteką Notifications lub nieprzetworzonym kodem XML.

Dodaj deklaracje przestrzeni nazw

using Windows.UI.Notifications;
using Windows.Data.Xml.Dom;

Tworzenie zawartości powiadomienia

// In a real app, these would be initialized with actual data
string from = "Jennifer Parker";
string subject = "Photos from our trip";
string body = "Check out these awesome photos I took while in New Zealand!";

// TODO - all values need to be XML escaped

// Construct the tile content as a string
string content = $@"
<tile>
    <visual>

        <binding template='TileMedium'>
            <text>{from}</text>
            <text hint-style='captionSubtle'>{subject}</text>
            <text hint-style='captionSubtle'>{body}</text>
        </binding>

        <binding template='TileWide'>
            <text hint-style='subtitle'>{from}</text>
            <text hint-style='captionSubtle'>{subject}</text>
            <text hint-style='captionSubtle'>{body}</text>
        </binding>

    </visual>
</tile>";

Tworzenie powiadomienia

// Load the string into an XmlDocument
XmlDocument doc = new XmlDocument();
doc.LoadXml(content);

// Then create the tile notification
var notification = new TileNotification(doc);

Tematy pokrewne

• Tworzenie kafelków adaptacyjnych
• Schemat zawartości kafelka
• Biblioteka powiadomień
• Pełny przykład kodu w witrynie GitHub
• przestrzeni nazw Windows.UI.Notifications
• Jak używać kolejki powiadomień (XAML)
• Dostarczanie powiadomień