チュートリアル: バックエンドサービス経由で Azure Notification Hubs を使用して Xamarin.Forms アプリにプッシュ通知を送信する

[アーティクル]
07/27/2020

サンプルダウンロードサンプルをダウンロードする

Xamarin.Forms の
Flutter
React ネイティブの

このチュートリアルでは、Azure Notification Hubs を使用して、Android と iOSを対象とする Xamarin.Forms アプリケーションプッシュ通知します。

ASP.NET Core Web API バックエンドは、最新かつ最適なインストールアプローチを使用して、クライアントのデバイス登録を処理するために使用されます。また、サービスはクロスプラットフォーム方式でプッシュ通知を送信します。

これらの操作は、バックエンド操作のNotification Hubs SDK を使用して処理されます。全体的なアプローチの詳細については、アプリバックエンドからの登録ドキュメントを参照してください。

このチュートリアルでは、次の手順を実行します。

プッシュ通知サービスと Azure Notification Hubs を設定します。
ASP.NET Core Web API バックエンドアプリケーションを作成します。
クロスプラットフォーム Xamarin.Forms アプリケーションを作成します。
プッシュ通知用にネイティブ Android プロジェクトを構成します。
プッシュ通知用にネイティブ iOS プロジェクトを構成します。
ソリューションをテストします。

前提条件

これに従うには、次のものが必要です。

Azure サブスクリプションリソースを作成および管理できます。
Visual Studio for Mac がインストールされている Mac、または Visual Studio 2019実行している PC。
Visual Studio 2019 ユーザーは、.NET と ASP.NET および Web 開発ワークロードを使用した Mobile 開発も必要です。
Android (物理デバイスまたはエミュレーターデバイス) または iOS (物理デバイスのみ) でアプリを実行する機能。

Android の場合は、次が必要です。

開発者が物理デバイスのロックを解除するか、エミュレーター (Google Play Services がインストールされた状態で API 26 以降を実行)。

iOS の場合は、次が必要です。

アクティブな Apple Developer Account。
(iOS 13.0 以降を実行している)開発者アカウントに登録物理 iOS デバイス。
.p12開発証明書キーチェーンにインストール、物理デバイスでアプリを実行できます。

手記

iOS シミュレーターはリモート通知をサポートしていないため、iOS でこのサンプルを探索するときは物理デバイスが必要です。ただし、このチュートリアルを完了するために、Android と iOS の両方でアプリを実行する必要はありません。

この最初の原則の例の手順は、以前の経験なしで実行できます。ただし、次の点を理解することでメリットが得られるでしょう。

Apple Developer Portal
ASP.NET Core と Web API
Google Firebase Console
Microsoft Azure と Azure Notification Hubsを使用して iOS アプリにプッシュ通知を送信します。
Xamarin と Xamarin.Formsをします。

大事な

提供される手順は、Visual Studio for Macに固有です。 Visual Studio 2019 を使用して操作を進めすることはできますが、調整にはいくつかの違いがある場合があります。たとえば、ユーザーインターフェイスとワークフローの説明、テンプレート名、環境の構成などです。

プッシュ通知サービスと Azure Notification Hub を設定する

このセクションでは、Firebase Cloud Messaging (FCM) と Apple Push Notification Services (APNS)を設定します。次に、これらのサービスを操作するための通知ハブを作成して構成します。

Firebase プロジェクトを作成し、Android 用 Firebase Cloud Messaging を有効にする

Firebase コンソールにサインインします。プロジェクト名として PushDemo 入力新しい Firebase プロジェクトを作成します。

手記

一意の名前が自動的に生成されます。既定では、これは、指定した名前の小文字のバリアントと、ダッシュで区切られた生成された番号で構成されます。グローバルに一意である場合は、これを変更できます。
プロジェクトを作成したら、[Firebase を Android アプリに追加] を選択します。

に追加する
[Add Firebase to your Android app]\(Firebase を Android アプリに追加する\) ページで、次の手順を実行します。
1. Android パッケージ名に、パッケージの名前を入力します。例: com.<organization_identifier>.<package_name>.
  
  を指定する
2. [アプリ登録] を選択します。
3. [google-services.jsonダウンロード] を選択します。次に、後で使用するためにファイルをローカルフォルダーに保存し、[次 ] を選択します。
4. [次選択します。
5. [続行 コンソール を選択する
  
  手記
  
  インストールの確認チェックがのため、[コンソールに進む] ボタンが有効になっていない場合は、[この手順スキップ選択します。
Firebase コンソールで、プロジェクトの歯車を選択します。次に、[プロジェクト設定]選択します。

手記

google-services.json ファイルをダウンロードしていない場合は、このページでダウンロードできます。
上部にある [クラウドメッセージング] タブに切り替えます。後で使用するために、サーバーキー をコピーして保存します。この値を使用して、通知ハブを構成します。

をコピーする

プッシュ通知用に iOS アプリを登録する

iOS アプリにプッシュ通知を送信するには、Apple にアプリケーションを登録し、プッシュ通知にも登録します。

まだアプリを登録していない場合は、Apple デベロッパーセンターの iOS プロビジョニングポータルを参照します。 Apple ID を使用してポータルにサインインし、証明書、識別子、プロファイル &に移動し、[識別子]を選択します。 + をクリックして新しいアプリを登録します。
[新しい識別子の登録] 画面で、[アプリ ID] ラジオボタンを選択します。次に、[続行]選択します。

iOS プロビジョニングポータル
新しいアプリの次の 3 つの値を更新し、[続行]選択します。
- 説明: アプリのわかりやすい名前を入力します。
- バンドル ID: フォームのバンドル ID 入力します。<organization_identifier>。アプリ配布ガイドのに記載されている<product_name>。次のスクリーンショットでは、mobcat 値が組織識別子として使用され、PushDemo 値が製品名として使用されています。
  
  iOS プロビジョニングポータル
- プッシュ通知の: [機能] セクションの [プッシュ通知] オプションをオンにします。
  
  を登録する
  
  このアクションにより、アプリ ID が生成され、情報の確認が要求されます。 [続行]選択し、[ 登録] を選択して新しいアプリ ID を確認します。
  
  を確認する
  
  の登録選択すると、新しいアプリ ID が [証明書、識別子 & プロファイル] ページに行項目として表示されます。
[証明書] の [識別子 & プロファイル] ページの [識別子]で、作成したアプリ ID の行項目を見つけます。次に、その行を選択して、[アプリ ID 構成の編集] 画面表示します。

Notification Hubs の証明書の作成

Apple Push Notification Services (APNS) で通知ハブを操作できるようにするために証明書が必要であり、次の 2 つの方法のいずれかで提供できます。

Notification Hub に直接アップロードできる p12 プッシュ証明書の作成 (元のアプローチ)
トークンベースの認証に使用できる p8 証明書の作成 (新しい推奨されるアプローチ)

新しいアプローチには、APNSのトークンベース (HTTP/2) 認証に関するページに記載されているように、多くの利点があります。必要な手順は少なくなりますが、特定のシナリオでも必須です。ただし、どちらの方法でもこのチュートリアルの目的で機能するため、両方の方法の手順が提供されています。

オプション 1: Notification Hub に直接アップロードできる p12 プッシュ証明書を作成する

Mac で、キーチェーンアクセスツールを実行します。 Utilities フォルダーまたはスタートパッドの Other フォルダーから開くことができます。
キーチェーンアクセス選択し、証明書アシスタント展開して、証明機関から証明書要求を選択します。

キーチェーンアクセスを使用して新しい証明書を要求する

手記

既定では、キーチェーンアクセスはリスト内の最初の項目を選択します。これは、証明書 カテゴリに属していて、Apple Worldwide Developer Relations 証明機関がリストの最初の項目でない場合に問題になる可能性があります。 CSR (証明書署名要求) を生成する前に、キー以外の項目があることを確認するか、Apple Worldwide Developer Relations 証明機関キーが選択されていることを確認します。
ユーザーの電子メールアドレスを選択し、共通名のの値を入力し、[ディスクに保存] 指定していることを確認し、[続行]選択します。 CA 電子メールアドレスは不要であるため、空白のままにします。
[名前を付けて保存]に証明書署名要求 (CSR) ファイルの名前入力し、[場所] で場所選択し、[保存] 選択します。

このアクションにより、選択した場所に CSR ファイル が保存されます。既定の場所はデスクトップです。ファイルに対して選択した場所を覚えておいてください。
iOS プロビジョニングポータルの証明書、識別子 & プロファイルページに戻り、チェックされた [プッシュ通知] オプションまで下にスクロールし、[ の構成] 選択して証明書を作成します。
[Apple Push Notification service TLS/SSL Certificates] ウィンドウが表示されます。 [開発 TLS/SSL 証明書] セクションの下にある [証明書の作成 ] ボタンを選択します。

新しい証明書 の作成画面が表示されます。

手記

このチュートリアルでは、開発証明書を使用します。運用環境の証明書を登録する場合も同じプロセスが使用されます。通知を送信するときは、必ず同じ種類の証明書を使用してください。
[ファイル選択] を選択し、CSR ファイルを保存した場所を参照し、証明書名をダブルクリックして読み込みます。次に、[続行]選択します。
ポータルで証明書を作成した後、ダウンロード ボタンを選択します。証明書を保存し、保存先の場所を覚えておいてください。

証明書がダウンロードされ、ダウンロード フォルダーにコンピューターに保存されます。

手記

既定では、ダウンロードした開発証明書には aps_development.cerという名前が付けられます。
ダウンロードしたプッシュ証明書の aps_development.cerをダブルクリックします。この操作により、次の図に示すように、キーチェーンに新しい証明書がインストールされます。

新しい証明書を示すキーチェーンアクセス証明書の一覧をする

手記

証明書内の名前は異なる場合がありますが、名前の前に Apple Development iOS Push Services が付き、適切なバンドル識別子が関連付けられます。
キーチェーンアクセスで、コントロール + 証明書 カテゴリで作成した新しいプッシュ証明書のをクリックします。 [エクスポート選択し、ファイルに名前を付け、p12 形式を選択して、[保存] 選択します。

証明書をパスワードで保護することもできますが、パスワードは省略可能です。パスワードの作成 バイパスする場合は、[OK] をクリックします。エクスポートした p12 証明書のファイル名と場所を書き留めます。これらは、APN での認証を有効にするために使用されます。

手記

p12 ファイルの名前と場所は、このチュートリアルで説明されているものとは異なる場合があります。

オプション 2: トークンベースの認証に使用できる p8 証明書を作成する

次の詳細を書き留めます。
- アプリ ID プレフィックス (チーム ID)
- バンドル ID
証明書、識別子 & プロファイルに戻り、[キーの] をクリックします。

手記

APNS用に構成されたキーが既にある場合は、作成直後にダウンロードした p8 証明書を再利用できます。その場合は、5までの 3 手順を無視できます。
[+] ボタン (または [キーの作成] ボタン) をクリックして、新しいキーを作成します。
適切な キー名 値を指定し、Apple Push Notifications サービス (APNS) オプションをオンにして、[続行] をクリックし、次の画面で [登録] をクリックします。
[ ダウンロード] をクリックし、p8 ファイル (プレフィックスは AuthKey_) をセキュリティで保護されたローカルディレクトリに移動し、[完了] クリック。

手記

p8 ファイルは安全な場所に保管してください (バックアップを保存してください)。キーをダウンロードした後は、サーバーのコピーが削除されるため、再ダウンロードできません。
キーで、作成したキー (または代わりに使用することを選択した場合は既存のキー) をクリックします。
キー ID 値を書き留めます。
Visual Studio Codeなど、任意の適切なアプリケーションで p8 証明書を開きます。キーの値 (----- BEGIN 秘密キー----- と ----- END 秘密キー-----) を書き留めます。

-----秘密キーを使用します-----
<key_value>
秘密キーを-----します-----

手記

これは、後で Notification Hubを構成するために使用されるトークン値です。

これらの手順の最後には、「APNS 情報を使用して通知ハブを構成する後で使用するための次の情報が必要です。

チーム ID (手順 1 を参照)
バンドル ID (手順 1 を参照)
キー ID (手順 7 を参照)
トークン値 (手順 8 で取得した p8 キー値)

アプリのプロビジョニングプロファイルを作成する

iOS プロビジョニングポータルに戻り、[証明書 ]、[識別子]、[プロファイル] &の順に選択し、左側のメニューから [プロファイル] を選択し、+ を選択して新しいプロファイルを作成します。 [新しいプロビジョニングプロファイルの登録] 画面が表示されます。
プロビジョニングプロファイル [開発] の下にある [iOS アプリ開発を選択し、[続行]選択します。
次に、[アプリ ID] ドロップダウンリストから作成したアプリ ID を選択し、[続行]選択します。

を選択する
[証明書の選択] ウィンドウで、コード署名に使用する開発証明書を選択し、[続行]選択します。

手記

この証明書は、前の手順で作成したプッシュ証明書ではありません。これは開発証明書です。存在しない場合は、このチュートリアルの前提条件であるため、作成する必要があります。開発者証明書は、Apple Developer Portal、xcode、または Visual Studio使用して作成できます。
証明書、識別子 & プロファイル ページに戻り、左側のメニューから プロファイル を選択し、+ を選択して新しいプロファイルを作成します。 [新しいプロビジョニングプロファイルの登録] 画面が表示されます。
証明書の選択 ウィンドウで、作成した開発証明書を選択します。次に、[続行]選択します。
次に、テストに使用するデバイスを選択し、[続行]選択します。
最後に、[プロビジョニングプロファイル名]でプロファイルの名前選択し、[の生成] 選択します。
新しいプロビジョニングプロファイルが作成されたら、[のダウンロード] 選択します。保存先の場所を覚えておいてください。
プロビジョニングプロファイルの場所を参照し、それをダブルクリックして開発用コンピューターにインストールします。

通知ハブを作成する

このセクションでは、通知ハブを作成し、APNSを使用して認証を構成します。 p12 プッシュ証明書またはトークンベースの認証を使用できます。既に作成した通知ハブを使用する場合は、手順 5 に進むことができます。

Azureにサインインします。
[リソース作成] をクリックし、Notification Hub検索して選択し、[の作成] クリックします。
次のフィールドを更新し、の作成クリックします。

基本的な詳細をする

サブスクリプション: ドロップダウンリストからターゲット サブスクリプション を選択します
リソースグループ: 新しい リソースグループ を作成する (または既存のものを選択する)

名前空間の詳細をする

Notification Hub 名前空間:Notification Hub 名前空間のグローバルに一意の名前を入力します

手記

このフィールドに 新しい の作成オプションが選択されていることを確認します。

通知ハブの詳細をする

通知ハブ:Notification Hub の名前を入力します
場所: ドロップダウンリストから適切な場所を選択します
価格レベル: 既定の Free オプションを保持する

手記

Free レベルのハブの最大数に達していない限り。
Notification Hub がプロビジョニングされたら、そのリソースに移動します。
新しい Notification Hubに移動します。
一覧からアクセスポリシーを選択します ([manage] の下 )。
ポリシー名の 値と、対応する 接続文字列 値を書き留めます。

APNS 情報を使用して Notification Hub を構成する

Notification Servicesで、Apple 選択し、「Notification Hubs の証明書の作成」セクションで前に選択した方法に基づいて適切な手順に従います。

手記

ストアからアプリを購入したユーザーにプッシュ通知を送信する場合にのみ、アプリケーションモードの の運用を使用します。

オプション 1: .p12 プッシュ証明書の使用

[証明書選択します。
ファイルアイコンを選択します。
先ほどエクスポートした .p12 ファイルを選択し、[を開く] 選択します。
必要に応じて、正しいパスワードを指定します。
サンドボックスモード選択します。
[保存]を選択します。

オプション 2: トークンベースの認証を使用する

[トークン選択します。
前に取得した次の値を入力します。
- キー ID
- バンドル ID
- チーム ID
- トークンの
[サンドボックス選択します。
[保存]を選択します。

FCM 情報を使用して通知ハブを構成する

左側 メニューの [設定] セクションで Google (GCM/FCM) を選択します。
Google Firebase Consoleから、サーバーキー 入力します。
ツールバー [保存] を選択します。

ASP.NET Core Web API バックエンドアプリケーションを作成する

このセクションでは、ASP.NET Core Web API バックエンドを作成して、デバイス登録と Xamarin.Forms モバイルアプリへの通知の送信を処理します。

Web プロジェクトを作成する

Visual Studioで、[ファイル][新しいソリューション]選択します。
[.NET CoreAppASP.NET CoreAPINextを ] を選択します。
[新しい ASP.NET Core Web API の構成] ダイアログで、.NET Core 3.1のターゲットフレームワーク選択します。
プロジェクト名に「PushDemoApi 入力し、[作成]選択します。
デバッグを開始 (コマンド + Enter) して、テンプレート化されたアプリをテストします。
手記

テンプレートアプリは、launchUrlとして WeatherForecastController を使用するように構成されています。これは、プロパティ>launchSettings.jsonで設定されます。

無効な開発証明書が見つかりました メッセージが表示された場合:
1. [はい] をクリックして、"dotnet dev-certs https" ツールを実行してこれを修正することに同意します。 "dotnet dev-certs https" ツールでは、証明書のパスワードとキーチェーンのパスワードの入力を求められます。
2. インストールを し、新しい証明書を信頼するように求められたら、[はい] をクリックし、キーチェーンのパスワードを入力します。
Controllers フォルダーを展開し、WeatherForecastController.csを削除します。
WeatherForecast.csを削除します。
Secret Manager ツールを使用してローカル構成値を設定します。シークレットをソリューションから切り離すことで、最終的にソース管理が行われることはありません。ターミナル開き、プロジェクトファイルのディレクトリに移動し、次のコマンドを実行します。
```
dotnet user-secrets init
dotnet user-secrets set "NotificationHub:Name" <value>
dotnet user-secrets set "NotificationHub:ConnectionString" <value>
```
プレースホルダーの値を、独自の通知ハブ名と接続文字列の値に置き換えます。通知ハブの作成セクションでメモしておきます。それ以外の場合は、Azureで検索できます。

NotificationHub:Name:
の概要の上部にある Essentials 概要の名を参照してください。

NotificationHub:ConnectionString:
アクセスポリシーの DefaultFullSharedAccessSignature のを参照してください

手記

運用環境のシナリオでは、Azure KeyVault をして接続文字列を安全に格納するオプションを確認できます。わかりやすくするために、シークレットは Azure App Service アプリケーション設定に追加されます。

API キーを使用してクライアントを認証する (省略可能)

API キーはトークンほど安全ではありませんが、このチュートリアルでは十分です。 API キーは、ASP.NET ミドルウェアを使用して簡単に構成できます。

API キー をローカル構成値に追加します。
```
dotnet user-secrets set "Authentication:ApiKey" <value>
```
手記

プレースホルダーの値を独自の値に置き換え、メモする必要があります。
コントロールPushDemoApi プロジェクトの [] をクリックし、[ の追加] メニューから [新しいフォルダーを選択し、フォルダー名として認証を使用してを追加 ] をクリックします。
コントロール認証フォルダーの [] をクリックし、[追加] メニューの [新しいファイル]< 選択します。

[全般][空のクラス]選択し、[名]に ApiKeyAuthOptions.cs を入力し、[新規] クリック、次の実装を追加します。

using Microsoft.AspNetCore.Authentication;

namespace PushDemoApi.Authentication
{
    public class ApiKeyAuthOptions : AuthenticationSchemeOptions
    {
        public const string DefaultScheme = "ApiKey";
        public string Scheme => DefaultScheme;
        public string ApiKey { get; set; }
    }
}

ApiKeyAuthHandler.csという名前 の Authentication フォルダーに空のクラス を追加し、次の実装を追加します。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Text.Encodings.Web;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace PushDemoApi.Authentication
{
    public class ApiKeyAuthHandler : AuthenticationHandler<ApiKeyAuthOptions>
    {
        const string ApiKeyIdentifier = "apikey";

        public ApiKeyAuthHandler(
            IOptionsMonitor<ApiKeyAuthOptions> options,
            ILoggerFactory logger,
            UrlEncoder encoder,
            ISystemClock clock)
            : base(options, logger, encoder, clock) {}

        protected override Task<AuthenticateResult> HandleAuthenticateAsync()
        {
            string key = string.Empty;

            if (Request.Headers[ApiKeyIdentifier].Any())
            {
                key = Request.Headers[ApiKeyIdentifier].FirstOrDefault();
            }
            else if (Request.Query.ContainsKey(ApiKeyIdentifier))
            {
                if (Request.Query.TryGetValue(ApiKeyIdentifier, out var queryKey))
                    key = queryKey;
            }

            if (string.IsNullOrWhiteSpace(key))
                return Task.FromResult(AuthenticateResult.Fail("No api key provided"));

            if (!string.Equals(key, Options.ApiKey, StringComparison.Ordinal))
                return Task.FromResult(AuthenticateResult.Fail("Invalid api key."));

            var identities = new List<ClaimsIdentity> {
                new ClaimsIdentity("ApiKeyIdentity")
            };

            var ticket = new AuthenticationTicket(
                new ClaimsPrincipal(identities), Options.Scheme);

            return Task.FromResult(AuthenticateResult.Success(ticket));
        }
    }
}

手記

認証ハンドラーは、スキームの動作 (この場合はカスタム API キースキーム) を実装する型です。

別の Empty クラス を ApiKeyAuthenticationBuilderExtensions.csという名前の Authentication フォルダーに追加し、次の実装を追加します。

using System;
using Microsoft.AspNetCore.Authentication;

namespace PushDemoApi.Authentication
{
    public static class AuthenticationBuilderExtensions
    {
        public static AuthenticationBuilder AddApiKeyAuth(
            this AuthenticationBuilder builder,
            Action<ApiKeyAuthOptions> configureOptions)
        {
            return builder
                .AddScheme<ApiKeyAuthOptions, ApiKeyAuthHandler>(
                    ApiKeyAuthOptions.DefaultScheme,
                    configureOptions);
        }
    }
}

手記

この拡張メソッドは、ミドルウェア構成コードを簡略化 Startup.cs、より読みやすく、一般的に従いやすくします。

Startup.csで、ConfigureServices メソッドを更新して、サービスの呼び出しの下で API キー認証を構成します。AddControllers メソッド。

using PushDemoApi.Authentication;
using PushDemoApi.Models;
using PushDemoApi.Services;

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddAuthentication(options =>
    {
        options.DefaultAuthenticateScheme = ApiKeyAuthOptions.DefaultScheme;
        options.DefaultChallengeScheme = ApiKeyAuthOptions.DefaultScheme;
    }).AddApiKeyAuth(Configuration.GetSection("Authentication").Bind);
}

引き続き Startup.csで、Configure メソッドを更新して、UseAuthentication を呼び出し、アプリの IApplicationBuilderで UseAuthorization 拡張メソッドをします。これらのメソッドは、UseRouting 後、およびアプリの前呼び出されていることを確認します。UseEndpoints.
```
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseHttpsRedirection();

    app.UseRouting();

    app.UseAuthentication();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}
```
手記

UseAuthentication を呼び出すと、(ConfigureServicesから) 以前に登録された認証スキームを使用するミドルウェアが登録されます。これは、認証されるユーザーに依存するミドルウェアの前に呼び出す必要があります。

依存関係の追加とサービスの構成

ASP.NET Core では、依存関係挿入 (DI) ソフトウェア設計パターンがサポートされています。これは、クラスとその依存関係の間で制御の反転 (IoC) を実現するための手法です。

バックエンド操作に通知ハブと Notification Hubs SDK を使用することは、サービス内にカプセル化されます。サービスは登録され、適切な抽象化によって利用できるようになります。

Control + Dependencies フォルダーの [] をクリックし、[NuGet パッケージの管理]選択します。..。
Microsoft.Azure.NotificationHubs を検索し、チェックされていることを確認します。
[パッケージ追加] をクリックし、ライセンス条項同意するように求められたら[ に同意する] をクリックします。
コントロールPushDemoApi プロジェクトの [] をクリックし、[ の追加] メニューから [新しいフォルダー選択し、フォルダー名として [モデル] を使用してを追加をクリックします。
コントロールModels フォルダーの [] をクリックし、[ の追加] メニューから [新しいファイルを選択します。

[全般][空のクラス]選択し、[名]に PushTemplates.cs を入力し、[新規 ] をクリック次の実装を追加します。

namespace PushDemoApi.Models
{
    public class PushTemplates
    {
        public class Generic
        {
            public const string Android = "{ \"notification\": { \"title\" : \"PushDemo\", \"body\" : \"$(alertMessage)\"}, \"data\" : { \"action\" : \"$(alertAction)\" } }";
            public const string iOS = "{ \"aps\" : {\"alert\" : \"$(alertMessage)\"}, \"action\" : \"$(alertAction)\" }";
        }

        public class Silent
        {
            public const string Android = "{ \"data\" : {\"message\" : \"$(alertMessage)\", \"action\" : \"$(alertAction)\"} }";
            public const string iOS = "{ \"aps\" : {\"content-available\" : 1, \"apns-priority\": 5, \"sound\" : \"\", \"badge\" : 0}, \"message\" : \"$(alertMessage)\", \"action\" : \"$(alertAction)\" }";
        }
    }
}

手記

このクラスには、このシナリオで必要な汎用通知とサイレント通知のトークン化された通知ペイロードが含まれています。ペイロードは、サービスを介して既存のインストールを更新することなく実験できるように、インストールの外部で定義されます。この方法でのインストールの変更の処理は、このチュートリアルでは範囲外です。運用環境では、カスタムテンプレートすることを検討してください。

別の 空のクラス を DeviceInstallation.csという名前の Models フォルダーに追加し、次の実装を追加します。

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace PushDemoApi.Models
{
    public class DeviceInstallation
    {
        [Required]
        public string InstallationId { get; set; }

        [Required]
        public string Platform { get; set; }

        [Required]
        public string PushChannel { get; set; }

        public IList<string> Tags { get; set; } = Array.Empty<string>();
    }
}

別の 空のクラス を NotificationRequest.csという名前の Models フォルダーに追加し、次の実装を追加します。

using System;

namespace PushDemoApi.Models
{
    public class NotificationRequest
    {
        public string Text { get; set; }
        public string Action { get; set; }
        public string[] Tags { get; set; } = Array.Empty<string>();
        public bool Silent { get; set; }
    }
}

NotificationHubOptions.csという名前 の Models フォルダーに空のクラス をもう 1 つ追加し、次の実装を追加します。

using System.ComponentModel.DataAnnotations;

namespace PushDemoApi.Models
{
    public class NotificationHubOptions
    {
        [Required]
        public string Name { get; set; }

        [Required]
        public string ConnectionString { get; set; }
    }
}

Servicesと呼ばれる新しいフォルダーを PushDemoApi プロジェクトに追加します。

空のインターフェイス を INotificationService.csという名前の Services フォルダーに追加し、次の実装を追加します。

using System.Threading;
using System.Threading.Tasks;
using PushDemoApi.Models;

namespace PushDemoApi.Services
{
    public interface INotificationService
    {
        Task<bool> CreateOrUpdateInstallationAsync(DeviceInstallation deviceInstallation, CancellationToken token);
        Task<bool> DeleteInstallationByIdAsync(string installationId, CancellationToken token);
        Task<bool> RequestNotificationAsync(NotificationRequest notificationRequest, CancellationToken token);
    }
}

空のクラス を NotificationHubsService.csという名前の Services フォルダーに追加し、次のコードを追加して、INotificationService インターフェイスを実装します。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.NotificationHubs;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using PushDemoApi.Models;

namespace PushDemoApi.Services
{
    public class NotificationHubService : INotificationService
    {
        readonly NotificationHubClient _hub;
        readonly Dictionary<string, NotificationPlatform> _installationPlatform;
        readonly ILogger<NotificationHubService> _logger;

        public NotificationHubService(IOptions<NotificationHubOptions> options, ILogger<NotificationHubService> logger)
        {
            _logger = logger;
            _hub = NotificationHubClient.CreateClientFromConnectionString(
                options.Value.ConnectionString,
                options.Value.Name);

            _installationPlatform = new Dictionary<string, NotificationPlatform>
            {
                { nameof(NotificationPlatform.Apns).ToLower(), NotificationPlatform.Apns },
                { nameof(NotificationPlatform.Fcm).ToLower(), NotificationPlatform.Fcm }
            };
        }

        public async Task<bool> CreateOrUpdateInstallationAsync(DeviceInstallation deviceInstallation, CancellationToken token)
        {
            if (string.IsNullOrWhiteSpace(deviceInstallation?.InstallationId) ||
                string.IsNullOrWhiteSpace(deviceInstallation?.Platform) ||
                string.IsNullOrWhiteSpace(deviceInstallation?.PushChannel))
                return false;

            var installation = new Installation()
            {
                InstallationId = deviceInstallation.InstallationId,
                PushChannel = deviceInstallation.PushChannel,
                Tags = deviceInstallation.Tags
            };

            if (_installationPlatform.TryGetValue(deviceInstallation.Platform, out var platform))
                installation.Platform = platform;
            else
                return false;

            try
            {
                await _hub.CreateOrUpdateInstallationAsync(installation, token);
            }
            catch
            {
                return false;
            }

            return true;
        }

        public async Task<bool> DeleteInstallationByIdAsync(string installationId, CancellationToken token)
        {
            if (string.IsNullOrWhiteSpace(installationId))
                return false;

            try
            {
                await _hub.DeleteInstallationAsync(installationId, token);
            }
            catch
            {
                return false;
            }

            return true;
        }

        public async Task<bool> RequestNotificationAsync(NotificationRequest notificationRequest, CancellationToken token)
        {
            if ((notificationRequest.Silent &&
                string.IsNullOrWhiteSpace(notificationRequest?.Action)) ||
                (!notificationRequest.Silent &&
                (string.IsNullOrWhiteSpace(notificationRequest?.Text)) ||
                string.IsNullOrWhiteSpace(notificationRequest?.Action)))
                return false;

            var androidPushTemplate = notificationRequest.Silent ?
                PushTemplates.Silent.Android :
                PushTemplates.Generic.Android;

            var iOSPushTemplate = notificationRequest.Silent ?
                PushTemplates.Silent.iOS :
                PushTemplates.Generic.iOS;

            var androidPayload = PrepareNotificationPayload(
                androidPushTemplate,
                notificationRequest.Text,
                notificationRequest.Action);

            var iOSPayload = PrepareNotificationPayload(
                iOSPushTemplate,
                notificationRequest.Text,
                notificationRequest.Action);

            try
            {
                if (notificationRequest.Tags.Length == 0)
                {
                    // This will broadcast to all users registered in the notification hub
                    await SendPlatformNotificationsAsync(androidPayload, iOSPayload, token);
                }
                else if (notificationRequest.Tags.Length <= 20)
                {
                    await SendPlatformNotificationsAsync(androidPayload, iOSPayload, notificationRequest.Tags, token);
                }
                else
                {
                    var notificationTasks = notificationRequest.Tags
                        .Select((value, index) => (value, index))
                        .GroupBy(g => g.index / 20, i => i.value)
                        .Select(tags => SendPlatformNotificationsAsync(androidPayload, iOSPayload, tags, token));

                    await Task.WhenAll(notificationTasks);
                }

                return true;
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Unexpected error sending notification");
                return false;
            }
        }

        string PrepareNotificationPayload(string template, string text, string action) => template
            .Replace("$(alertMessage)", text, StringComparison.InvariantCulture)
            .Replace("$(alertAction)", action, StringComparison.InvariantCulture);

        Task SendPlatformNotificationsAsync(string androidPayload, string iOSPayload, CancellationToken token)
        {
            var sendTasks = new Task[]
            {
                _hub.SendFcmNativeNotificationAsync(androidPayload, token),
                _hub.SendAppleNativeNotificationAsync(iOSPayload, token)
            };

            return Task.WhenAll(sendTasks);
        }

        Task SendPlatformNotificationsAsync(string androidPayload, string iOSPayload, IEnumerable<string> tags, CancellationToken token)
        {
            var sendTasks = new Task[]
            {
                _hub.SendFcmNativeNotificationAsync(androidPayload, tags, token),
                _hub.SendAppleNativeNotificationAsync(iOSPayload, tags, token)
            };

            return Task.WhenAll(sendTasks);
        }
    }
}

手記

SendTemplateNotificationAsync に提供されるタグ式は、20 個のタグに制限されています。ほとんどの演算子では 6 に制限されていますが、この場合、式に含まれるのは OR (||) のみです。要求に 20 個を超えるタグがある場合は、複数の要求に分割する必要があります。詳細については、ルーティングとタグ式ドキュメントを参照してください。

Startup.csで、ConfigureServices メソッドを更新して、NotificationHubsService を INotificationServiceのシングルトン実装として追加します。


using PushDemoApi.Models;
using PushDemoApi.Services;

public void ConfigureServices(IServiceCollection services)
{
    ...

    services.AddSingleton<INotificationService, NotificationHubService>();

    services.AddOptions<NotificationHubOptions>()
        .Configure(Configuration.GetSection("NotificationHub").Bind)
        .ValidateDataAnnotations();
}

通知 API を作成する

コントロール + Controllers フォルダーの [] をクリックし、[ 追加] メニューから [新しいファイル 選択します。..。
[コアWeb API コントローラークラスASP.NET 選択し、名に「NotificationsController 」と入力し、[新しい] をクリックします。

手記

Visual Studio 2019でフォローしている場合は、読み取り/書き込みアクションを含む API コントローラー テンプレートを選択します。

ファイルの先頭に次の名前空間を追加します。

using System.ComponentModel.DataAnnotations;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using PushDemoApi.Models;
using PushDemoApi.Services;

ControllerBase から派生し、ApiController 属性で修飾されるように、テンプレート化されたコントローラーを更新します。
```
[ApiController]
[Route("api/[controller]")]
public class NotificationsController : ControllerBase
{
    // Templated methods here
}
```
手記

Controller 基本クラスはビューのサポートを提供しますが、この場合は必要ないため、代わりに ControllerBase 使用できます。 Visual Studio 2019でフォローしている場合は、この手順をスキップできます。
API キーセクションを使用してクライアントを認証するを完了する場合は、NotificationsController を Authorize 属性で修飾する必要があります。
```
[Authorize]
```
INotificationService の登録済みインスタンスを引数として受け入れるようにコンストラクターを更新し、読み取り専用メンバーに割り当てます。
```
readonly INotificationService _notificationService;

public NotificationsController(INotificationService notificationService)
{
    _notificationService = notificationService;
}
```
launchSettings.json (プロパティ フォルダー内) で、launchUrl を weatherforecast から api/notifications に変更し、RegistrationsControllerRoute 属性で指定された URL に一致させます。
デバッグを開始します (コマンド + Enter) して、アプリが新しい NotificationsController で動作していることを検証し、401 Unauthorized 状態を返します。

手記

Visual Studio がブラウザーでアプリを自動的に起動しない場合があります。 Postman 使用して、この時点から API をテストします。
新しい Postman タブで、要求を GET設定します。 applicationUrl プレースホルダーを、プロパティlaunchSettings.jsonにある https applicationUrl に置き換えて、次のアドレスを入力します。
```
<applicationUrl>/api/notifications
```
手記

既定のプロファイルの場合、applicationUrl は 'https://localhost:5001' にする必要があります。 IIS (Windows Visual Studio 2019 の既定値) を使用している場合は、代わりに iisSettings 項目で指定された applicationUrl を使用する必要があります。アドレスが正しくない場合は、404 応答を受け取ります。
API キーセクションを使用してクライアントを認証するを完了する場合は、apikey 値を含めるように要求ヘッダーを構成してください。

鍵価値

apikey <your_api_key>
[送信] ボタンをクリックします。

手記

200 OK 状態を受け取り、一部の JSON コンテンツが表示されます。

SSL 証明書検証警告を受け取った場合は、[設定]で Postman 設定 SSL 証明書の要求検証をオフにすることができます。

鍵	価値
apikey	<your_api_key>

NotificationsController.cs のテンプレート化されたクラスメソッドを次のコードに置き換えます。

[HttpPut]
[Route("installations")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<IActionResult> UpdateInstallation(
    [Required]DeviceInstallation deviceInstallation)
{
    var success = await _notificationService
        .CreateOrUpdateInstallationAsync(deviceInstallation, HttpContext.RequestAborted);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

[HttpDelete()]
[Route("installations/{installationId}")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<ActionResult> DeleteInstallation(
    [Required][FromRoute]string installationId)
{
    var success = await _notificationService
        .DeleteInstallationByIdAsync(installationId, CancellationToken.None);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

[HttpPost]
[Route("requests")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<IActionResult> RequestPush(
    [Required]NotificationRequest notificationRequest)
{
    if ((notificationRequest.Silent &&
        string.IsNullOrWhiteSpace(notificationRequest?.Action)) ||
        (!notificationRequest.Silent &&
        string.IsNullOrWhiteSpace(notificationRequest?.Text)))
        return new BadRequestResult();

    var success = await _notificationService
        .RequestNotificationAsync(notificationRequest, HttpContext.RequestAborted);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

API アプリを作成する

これで、バックエンドサービスをホストするための API App Azure App Service を作成します。

Azure portalにサインインします。
[リソース作成] をクリックし、API App検索して選択し、[の作成] クリックします。
次のフィールドを更新し、の作成クリックします。

アプリ名:
API アプリ のグローバルに一意の名前を入力します

サブスクリプション:
通知ハブを作成したのと同じターゲット サブスクリプション を選択します。

リソースグループ:
通知ハブを作成したのと同じ リソースグループ を選択します。

App Service プラン/場所:
新しい App Service プラン を作成する

手記

既定のオプションから、SSL サポートを含むプランに変更します。それ以外の場合は、モバイルアプリを操作するときに適切な手順を実行して、http 要求ブロックされないようにする必要があります。

Application Insights:
推奨されるオプション (その名前を使用して新しいリソースが作成されます) をそのまま使用するか、既存のリソースを選択します。
API アプリ がプロビジョニングされたら、そのリソースに移動します。
の [概要]の上部にある Essentials の概要に、URL プロパティを書き留めます。この URL は、このチュートリアルの後半で使用する バックエンドエンドポイントの です。

手記

この URL では、前に指定した API アプリ名が、https://<app_name>.azurewebsites.net形式で使用されます。
一覧から構成を選択します ([設定])。

以下の各設定で、[新しいアプリケーション設定をクリックして名のと値のを入力し、[OK]クリックします。

名前	価値
`Authentication:ApiKey`	<api_key_value>
`NotificationHub:Name`	<hub_name_value>
`NotificationHub:ConnectionString`	<hub_connection_string_value>

手記

これらは、ユーザー設定で以前に定義した設定と同じです。これらをコピーできる必要があります。 Authentication:ApiKey 設定は、API キーセクションを使用してクライアントを認証するを完了することを選択した場合にのみ必要です。運用環境のシナリオでは、Azure KeyVaultなどのオプションを確認できます。これらは、この場合にわかりやすくするためにアプリケーション設定として追加されています。

すべてのアプリケーション設定が追加されたら、保存をクリックし、[続行]します。

バックエンドサービスを発行する

次に、API アプリにアプリをデプロイして、すべてのデバイスからアクセスできるようにします。

手記

次の手順は、Visual Studio for Macに固有です。 Windows Visual Studio 2019 でフォローしている場合、発行フローは異なります。 WindowsAzure App Service への発行に関するページを参照してください。

まだ行っていない場合は、構成を Debug から Release に変更します。
ControlPushDemoApi プロジェクトクリックし、[発行] メニューから [Azure に発行] 選択。
認証フローに従う必要がある場合は、それに従います。前の手順で使用したアカウントを使用、API アプリのセクションを作成します。
前に作成した Azure App Service API アプリを発行ターゲットとして一覧から選択し、[発行] をクリックします。

ウィザードが完了すると、アプリが Azure に発行され、アプリが開きます。まだ行っていない場合は、URL を書き留めておきます。この URL は、このチュートリアルの後半で使用する バックエンドエンドポイントの です。

発行された API の検証

Postman 新しいタブを開き、PUT 要求を設定し、以下のアドレスを入力します。プレースホルダーを、前のバックエンドサービスのセクションでメモしたベースアドレスに置き換えます。
```
https://<app_name>.azurewebsites.net/api/notifications/installations
```
手記

ベースアドレスは、https://<app_name>.azurewebsites.net/ の形式にする必要があります
API キーセクションを使用してクライアントを認証するを完了する場合は、apikey 値を含めるように要求ヘッダーを構成してください。

鍵価値

apikey <your_api_key>
Bodyの raw オプションを選択し、書式設定オプションの一覧から JSON 選択し、JSON コンテンツプレースホルダーを含めます。
```
{}
```
[送信] をクリックします。

手記

サービスから 422 UnprocessableEntity 状態を受け取る必要があります。
手順 1 から 4 をもう一度実行しますが、今回は要求エンドポイントを指定して、400 Bad Request 応答を受け取ったかどうかを検証します。
```
https://<app_name>.azurewebsites.net/api/notifications/requests
```

鍵	価値
apikey	<your_api_key>

手記

クライアントモバイルアプリからプラットフォーム固有の情報が必要になるため、有効な要求データを使用して API をテストすることはできません。

クロスプラットフォーム Xamarin.Forms アプリケーションを作成する

このセクションでは、クロスプラットフォームの方法でプッシュ通知を実装するモバイルアプリケーション Xamarin.Forms を構築します。

これにより、作成したバックエンドサービスを介して通知ハブを登録および登録解除できます。

アクションが指定され、アプリがフォアグラウンドにある場合、アラートが表示されます。それ以外の場合、通知は通知センターに表示されます。

手記

通常、登録 (および登録解除) アクションは、明示的なユーザー登録/登録解除の入力なしで、アプリケーションライフサイクルの適切な時点 (または最初の実行エクスペリエンスの一部として) 実行します。ただし、この例では、この機能をより簡単に調査およびテストできるようにするために、明示的なユーザー入力が必要になります。

Xamarin.Forms ソリューションを作成する

Visual Studioで、テンプレートとして空のフォームアプリを使用し、プロジェクト名の PushDemo 入力して、新しい Xamarin.Forms ソリューションを作成します。

手記

[空のフォームアプリの の構成] ダイアログで、組織識別子 が以前に使用した値と一致し、Android と iOS ターゲットの両方がチェックされていることを確認します。
コントロールPushDemo ソリューションの [] をクリックし、[NuGet パッケージの更新]選択します。
Control + PushDemo ソリューションの [] をクリックし、[NuGet パッケージの管理] 選択します。.
Newtonsoft.Json 検索し、チェックされていることを確認します。
[パッケージ追加] をクリックし、ライセンス条項同意するように求められたら[ に同意する] をクリックします。
各ターゲットプラットフォーム (Command + Enter) でアプリをビルドして実行し、テンプレート化されたアプリの実行をデバイスでテストします。

クロスプラットフォームコンポーネントを実装する

コントロールPushDemo プロジェクトのをクリックし、[ の追加] メニューから [新しいフォルダー選択し、フォルダー名として [モデル] を使用して [ の追加] クリックします。
コントロールModels フォルダーの [] をクリックし、[ の追加] メニューから [新しいファイルを選択します。

[全般][空のクラス]選択し、「DeviceInstallation.cs」と入力して、次の実装を追加します。

using System.Collections.Generic;
using Newtonsoft.Json;

namespace PushDemo.Models
{
    public class DeviceInstallation
    {
        [JsonProperty("installationId")]
        public string InstallationId { get; set; }

        [JsonProperty("platform")]
        public string Platform { get; set; }

        [JsonProperty("pushChannel")]
        public string PushChannel { get; set; }

        [JsonProperty("tags")]
        public List<string> Tags { get; set; } = new List<string>();
    }
}

空の列挙 を、次の実装で PushDemoAction.cs という Models フォルダーに追加します。

namespace PushDemo.Models
{
    public enum PushDemoAction
    {
        ActionA,
        ActionB
    }
}

Services という PushDemo プロジェクトに新しいフォルダーを追加、次の実装を使用して、ServiceContainer.cs という名前の 空のクラス をそのフォルダーに追加します。

using System;
using System.Collections.Generic;

namespace PushDemo.Services
{
   public static class ServiceContainer
   {
       static readonly Dictionary<Type, Lazy<object>> services
           = new Dictionary<Type, Lazy<object>>();

       public static void Register<T>(Func<T> function)
           => services[typeof(T)] = new Lazy<object>(() => function());

       public static T Resolve<T>()
           => (T)Resolve(typeof(T));

       public static object Resolve(Type type)
       {
           {
               if (services.TryGetValue(type, out var service))
                   return service.Value;

               throw new KeyNotFoundException($"Service not found for type '{type}'");
           }
       }
   }
}

手記

これは、XamCAT リポジトリから ServiceContainer クラスのトリミングされたバージョンです。軽量の IoC (制御の反転) コンテナーとして使用されます。

空のインターフェイス を IDeviceInstallationService.csという名前の Services フォルダーに追加し、次のコードを追加します。
```
using PushDemo.Models;

namespace PushDemo.Services
{
    public interface IDeviceInstallationService
    {
        string Token { get; set; }
        bool NotificationsSupported { get; }
        string GetDeviceId();
        DeviceInstallation GetDeviceInstallation(params string[] tags);
    }
}
```
手記

このインターフェイスは、後で各ターゲットによって実装およびブートストラップされ、プラットフォーム固有の機能を提供し、バックエンドサービスに必要な情報 DeviceInstallation します。
INotificationRegistrationService.csという名前の Services フォルダーに別の 空のインターフェイス を追加し、次のコードを追加します。
```
using System.Threading.Tasks;

namespace PushDemo.Services
{
    public interface INotificationRegistrationService
    {
        Task DeregisterDeviceAsync();
        Task RegisterDeviceAsync(params string[] tags);
        Task RefreshRegistrationAsync();
    }
}
```
手記

これにより、クライアントとバックエンドサービスの間の相互作用が処理されます。
INotificationActionService.csという名前の Services フォルダーに別の 空のインターフェイス を追加し、次のコードを追加します。
```
namespace PushDemo.Services
{
    public interface INotificationActionService
    {
        void TriggerAction(string action);
    }
}
```
手記

これは、通知アクションの処理を一元化するための簡単なメカニズムとして使用されます。
INotificationActionServiceから派生した IPushDemoNotificationActionService.cs という名前の Services フォルダーに、次の実装を使用して、空のインターフェイス を追加します。
```
using System;
using PushDemo.Models;

namespace PushDemo.Services
{
    public interface IPushDemoNotificationActionService : INotificationActionService
    {
        event EventHandler<PushDemoAction> ActionTriggered;
    }
}
```
手記

この型は、PushDemo アプリケーションに固有であり、PushDemoAction 列挙型を使用して、厳密に型指定された方法でトリガーされるアクションを識別します。

次のコードを使用して、INotificationRegistrationService を実装 NotificationRegistrationService.cs という名前の Services フォルダーに、空のクラス を追加します。

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using PushDemo.Models;
using Xamarin.Essentials;

namespace PushDemo.Services
{
    public class NotificationRegistrationService : INotificationRegistrationService
    {
        const string RequestUrl = "api/notifications/installations";
        const string CachedDeviceTokenKey = "cached_device_token";
        const string CachedTagsKey = "cached_tags";

        string _baseApiUrl;
        HttpClient _client;
        IDeviceInstallationService _deviceInstallationService;

        public NotificationRegistrationService(string baseApiUri, string apiKey)
        {
            _client = new HttpClient();
            _client.DefaultRequestHeaders.Add("Accept", "application/json");
            _client.DefaultRequestHeaders.Add("apikey", apiKey);

            _baseApiUrl = baseApiUri;
        }

        IDeviceInstallationService DeviceInstallationService
            => _deviceInstallationService ??
                (_deviceInstallationService = ServiceContainer.Resolve<IDeviceInstallationService>());

        public async Task DeregisterDeviceAsync()
        {
            var cachedToken = await SecureStorage.GetAsync(CachedDeviceTokenKey)
                .ConfigureAwait(false);

            if (cachedToken == null)
                return;

            var deviceId = DeviceInstallationService?.GetDeviceId();

            if (string.IsNullOrWhiteSpace(deviceId))
                throw new Exception("Unable to resolve an ID for the device.");

            await SendAsync(HttpMethod.Delete, $"{RequestUrl}/{deviceId}")
                .ConfigureAwait(false);

            SecureStorage.Remove(CachedDeviceTokenKey);
            SecureStorage.Remove(CachedTagsKey);
        }

        public async Task RegisterDeviceAsync(params string[] tags)
        {
            var deviceInstallation = DeviceInstallationService?.GetDeviceInstallation(tags);

            await SendAsync<DeviceInstallation>(HttpMethod.Put, RequestUrl, deviceInstallation)
                .ConfigureAwait(false);

            await SecureStorage.SetAsync(CachedDeviceTokenKey, deviceInstallation.PushChannel)
                .ConfigureAwait(false);

            await SecureStorage.SetAsync(CachedTagsKey, JsonConvert.SerializeObject(tags));
        }

        public async Task RefreshRegistrationAsync()
        {
            var cachedToken = await SecureStorage.GetAsync(CachedDeviceTokenKey)
                .ConfigureAwait(false);

            var serializedTags = await SecureStorage.GetAsync(CachedTagsKey)
                .ConfigureAwait(false);

            if (string.IsNullOrWhiteSpace(cachedToken) ||
                string.IsNullOrWhiteSpace(serializedTags) ||
                string.IsNullOrWhiteSpace(DeviceInstallationService.Token) ||
                cachedToken == DeviceInstallationService.Token)
                return;

            var tags = JsonConvert.DeserializeObject<string[]>(serializedTags);

            await RegisterDeviceAsync(tags);
        }

        async Task SendAsync<T>(HttpMethod requestType, string requestUri, T obj)
        {
            string serializedContent = null;

            await Task.Run(() => serializedContent = JsonConvert.SerializeObject(obj))
                .ConfigureAwait(false);

            await SendAsync(requestType, requestUri, serializedContent);
        }

        async Task SendAsync(
            HttpMethod requestType,
            string requestUri,
            string jsonRequest = null)
        {
            var request = new HttpRequestMessage(requestType, new Uri($"{_baseApiUrl}{requestUri}"));

            if (jsonRequest != null)
                request.Content = new StringContent(jsonRequest, Encoding.UTF8, "application/json");

            var response = await _client.SendAsync(request).ConfigureAwait(false);

            response.EnsureSuccessStatusCode();
        }
    }
}

手記

apiKey 引数は、API キーセクションを使用してクライアントを認証するを完了することを選択した場合にのみ必要です。

次のコードを使用して、IPushDemoNotificationActionService を実装 PushDemoNotificationActionService.cs という名前の Services フォルダーに、空のクラス を追加します。

using System;
using System.Collections.Generic;
using System.Linq;
using PushDemo.Models;

namespace PushDemo.Services
{
    public class PushDemoNotificationActionService : IPushDemoNotificationActionService
    {
        readonly Dictionary<string, PushDemoAction> _actionMappings = new Dictionary<string, PushDemoAction>
        {
            { "action_a", PushDemoAction.ActionA },
            { "action_b", PushDemoAction.ActionB }
        };

        public event EventHandler<PushDemoAction> ActionTriggered = delegate { };

        public void TriggerAction(string action)
        {
            if (!_actionMappings.TryGetValue(action, out var pushDemoAction))
                return;

            List<Exception> exceptions = new List<Exception>();

            foreach (var handler in ActionTriggered?.GetInvocationList())
            {
                try
                {
                    handler.DynamicInvoke(this, pushDemoAction);
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                }
            }

            if (exceptions.Any())
                throw new AggregateException(exceptions);
        }
    }
}

次の実装を使用して、Config.cs と呼ばれる PushDemo プロジェクトに 空のクラス を追加します。
```
namespace PushDemo
{
    public static partial class Config
    {
        public static string ApiKey = "API_KEY";
        public static string BackendServiceEndpoint = "BACKEND_SERVICE_ENDPOINT";
    }
}
```
手記

これは、シークレットをソース管理から除外する簡単な方法として使用されます。これらの値は、自動ビルドの一部として置き換えたり、ローカル部分クラスを使用してオーバーライドしたりできます。これは次の手順で行います。

ApiKey フィールドは、API キーセクションを使用してクライアントを認証するを完了することを選択した場合にのみ必要です。
次の実装で Config.local_secrets.cs と呼ばれる PushDemo プロジェクトに、空のクラスをもう 1 つ追加します。
```
namespace PushDemo
{
    public static partial class Config
    {
        static Config()
        {
            ApiKey = "<your_api_key>";
            BackendServiceEndpoint = "<your_api_app_url>";
        }
    }
}
```
手記

プレースホルダーの値を独自の値に置き換えます。バックエンドサービスを構築するときに、これらをメモしておく必要があります。 API アプリの URL が https://<api_app_name>.azurewebsites.net/されている必要があります。このファイルをコミットしないように、gitignore ファイルに *.local_secrets.* を追加することを忘れないでください。

ApiKey フィールドは、API キーセクションを使用してクライアントを認証するを完了することを選択した場合にのみ必要です。

空のクラス を、次の実装で Bootstrap.cs 呼び出された PushDemo プロジェクトに追加します。

using System;
using PushDemo.Services;

namespace PushDemo
{
    public static class Bootstrap
    {
        public static void Begin(Func<IDeviceInstallationService> deviceInstallationService)
        {
            ServiceContainer.Register(deviceInstallationService);

            ServiceContainer.Register<IPushDemoNotificationActionService>(()
                => new PushDemoNotificationActionService());

            ServiceContainer.Register<INotificationRegistrationService>(()
                => new NotificationRegistrationService(
                    Config.BackendServiceEndpoint,
                    Config.ApiKey));
        }
    }
}

手記

Begin メソッドは、iDeviceInstallationServiceのプラットフォーム固有の実装をアプリが起動したときに、各プラットフォーム呼び出されます。

NotificationRegistrationServiceapiKey コンストラクター引数は、API キーセクションを使用してクライアントを認証するを完了することを選択した場合にのみ必要です。

クロスプラットフォーム UI を実装する

PushDemo プロジェクトで MainPage.xaml 開き、StackLayout コントロールを次のように置き換えます。

<StackLayout VerticalOptions="EndAndExpand"  
             HorizontalOptions="FillAndExpand"
             Padding="20,40">
    <Button x:Name="RegisterButton"
            Text="Register"
            Clicked="RegisterButtonClicked" />
    <Button x:Name="DeregisterButton"
            Text="Deregister"
            Clicked="DeregisterButtonClicked" />
</StackLayout>

MainPage.xaml.csで、INotificationRegistrationService 実装への参照を格納するために、読み取り専用の バッキングフィールドを追加します。
```
readonly INotificationRegistrationService _notificationRegistrationService;
```
MainPage コンストラクターで、ServiceContainer を使用して INotificationRegistrationService 実装を解決し、notificationRegistrationService バッキングフィールドに割り当てます。
```
public MainPage()
{
    InitializeComponent();

    _notificationRegistrationService =
        ServiceContainer.Resolve<INotificationRegistrationService>();
}
```

対応する Register登録解除メソッドを呼び出す Clicked イベント、RegisterButton および deregisterButton ボタンのイベントハンドラーを実装します。

void RegisterButtonClicked(object sender, EventArgs e)
    => _notificationRegistrationService.RegisterDeviceAsync().ContinueWith((task)
        => { ShowAlert(task.IsFaulted ?
                task.Exception.Message :
                $"Device registered"); });

void DeregisterButtonClicked(object sender, EventArgs e)
    => _notificationRegistrationService.DeregisterDeviceAsync().ContinueWith((task)
        => { ShowAlert(task.IsFaulted ?
                task.Exception.Message :
                $"Device deregistered"); });

void ShowAlert(string message)
    => MainThread.BeginInvokeOnMainThread(()
        => DisplayAlert("PushDemo", message, "OK").ContinueWith((task)
            => { if (task.IsFaulted) throw task.Exception; }));

App.xaml.csで、次の名前空間が参照されていることを確認します。

using PushDemo.Models;
using PushDemo.Services;
using Xamarin.Essentials;
using Xamarin.Forms;

IPushDemoNotificationActionServiceActionTriggered イベントのイベントハンドラーを実装します。

void NotificationActionTriggered(object sender, PushDemoAction e)
    => ShowActionAlert(e);

void ShowActionAlert(PushDemoAction action)
    => MainThread.BeginInvokeOnMainThread(()
        => MainPage?.DisplayAlert("PushDemo", $"{action} action received", "OK")
            .ContinueWith((task) => { if (task.IsFaulted) throw task.Exception; }));

App コンストラクターで、ServiceContainer を使用して IPushNotificationActionService 実装を解決し、IPushDemoNotificationActionServiceActionTriggered イベントをサブスクライブします。
```
public App()
{
    InitializeComponent();

    ServiceContainer.Resolve<IPushDemoNotificationActionService>()
        .ActionTriggered += NotificationActionTriggered;

    MainPage = new MainPage();
}
```
手記

これは、プッシュ通知アクションの受信と伝達を示すだけのものです。通常、これらは、ルート Page(この場合は MainPage 経由でアラートを表示するのではなく、特定のビューに移動したり、データを更新したりするなど、サイレントに処理されます。

プッシュ通知用にネイティブ Android プロジェクトを構成する

パッケージ名とアクセス許可を検証する

PushDemo.Androidで、[プロジェクトオプション] を開き、[ビルド] セクションから Android アプリケーションをします。
パッケージ名、Firebase ConsolePushDemo プロジェクトで使用した値と一致することを確認します。 パッケージ名 は、com.<organization>.pushdemo形式でした。
最小 Android バージョン を Android 8.0 (API レベル 26) に設定し、ターゲット Android バージョン を最新の API レベルに設定します。

手記

このチュートリアルでは、API レベル 26 以上実行されているデバイスのみがサポートされていますが、古いバージョンを実行しているデバイスをサポートするように拡張することはできます。
[必要なアクセス許可]で、インターネットと READ_PHONE_STATE のアクセス許可有効になっていることを確認します。
[OK] クリックします

Xamarin Google Play Services ベースと Xamarin.Firebase.Messaging パッケージを追加する

PushDemo.Androidで、[コントロール][パッケージ] フォルダーの [] をクリック、[NuGet パッケージの管理]選択します。..。
Xamarin.GooglePlayServices.Base (地下ではなく) 検索し、チェックされていることを確認します。
Xamarin.Firebase.Messaging 検索し、チェックされていることを確認します。
[パッケージ追加] をクリックし、ライセンス条項同意するように求められたら、[ に同意 ] をクリックします。

Google Services JSON ファイルを追加する

コントロールプロジェクトの [] をクリックし、[追加] メニューから [既存のファイル選択します。.. します。
Firebase コンソールで PushDemo プロジェクトを設定したときに先ほどダウンロードした google-services.json ファイルを選択、[を開く] クリックします。
メッセージが表示されたら、ファイルをディレクトリにコピーすることを選択します。
コントロール + PushDemo.Android プロジェクト内から google-services.json ファイルの をクリックし、GoogleServicesJson が ビルドアクションとして設定されていることを確認します。

Android のプッシュ通知を処理する

コントロールプロジェクトの [] をクリックし、[追加] メニューから [新しいフォルダー選択し、フォルダー名として Services を使用してを追加 ] をクリックします。
コントロールServices フォルダーの [] をクリックし、[追加] メニューから [新しいファイル]... 選択します。

[全般][空のクラス]選択し、[名]に DeviceInstallationService.cs を入力し、[新規] クリック、次の実装を追加します。

using System;
using Android.App;
using Android.Gms.Common;
using PushDemo.Models;
using PushDemo.Services;
using static Android.Provider.Settings;

namespace PushDemo.Droid.Services
{
    public class DeviceInstallationService : IDeviceInstallationService
    {
        public string Token { get; set; }

        public bool NotificationsSupported
            => GoogleApiAvailability.Instance
                .IsGooglePlayServicesAvailable(Application.Context) == ConnectionResult.Success;

        public string GetDeviceId()
            => Secure.GetString(Application.Context.ContentResolver, Secure.AndroidId);

        public DeviceInstallation GetDeviceInstallation(params string[] tags)
        {
            if (!NotificationsSupported)
                throw new Exception(GetPlayServicesError());

            if (string.IsNullOrWhiteSpace(Token))
                throw new Exception("Unable to resolve token for FCM");

            var installation = new DeviceInstallation
            {
                InstallationId = GetDeviceId(),
                Platform = "fcm",
                PushChannel = Token
            };

            installation.Tags.AddRange(tags);

            return installation;
        }

        string GetPlayServicesError()
        {
            int resultCode = GoogleApiAvailability.Instance.IsGooglePlayServicesAvailable(Application.Context);

            if (resultCode != ConnectionResult.Success)
                return GoogleApiAvailability.Instance.IsUserResolvableError(resultCode) ?
                           GoogleApiAvailability.Instance.GetErrorString(resultCode) :
                           "This device is not supported";

            return "An error occurred preventing the use of push notifications";
        }
    }
}

手記

このクラスは、通知ハブ登録ペイロードの一部として一意の ID (Secure.AndroidIdを使用) を提供します。

PushNotificationFirebaseMessagingService.csという名前の Services フォルダーに、空のクラスをもう 1 つ追加し、次の実装を追加します。

using Android.App;
using Android.Content;
using Firebase.Messaging;
using PushDemo.Services;

namespace PushDemo.Droid.Services
{
    [Service]
    [IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]
    public class PushNotificationFirebaseMessagingService : FirebaseMessagingService
    {
        IPushDemoNotificationActionService _notificationActionService;
        INotificationRegistrationService _notificationRegistrationService;
        IDeviceInstallationService _deviceInstallationService;

        IPushDemoNotificationActionService NotificationActionService
            => _notificationActionService ??
                (_notificationActionService =
                ServiceContainer.Resolve<IPushDemoNotificationActionService>());

        INotificationRegistrationService NotificationRegistrationService
            => _notificationRegistrationService ??
                (_notificationRegistrationService =
                ServiceContainer.Resolve<INotificationRegistrationService>());

        IDeviceInstallationService DeviceInstallationService
            => _deviceInstallationService ??
                (_deviceInstallationService =
                ServiceContainer.Resolve<IDeviceInstallationService>());

        public override void OnNewToken(string token)
        {
            DeviceInstallationService.Token = token;

            NotificationRegistrationService.RefreshRegistrationAsync()
                .ContinueWith((task) => { if (task.IsFaulted) throw task.Exception; });
        }

        public override void OnMessageReceived(RemoteMessage message)
        {
            if(message.Data.TryGetValue("action", out var messageAction))
                NotificationActionService.TriggerAction(messageAction);
        }
    }
}

MainActivity.csで、次の名前空間がファイルの先頭に追加されていることを確認します。

using System;
using Android.App;
using Android.Content;
using Android.Content.PM;
using Android.OS;
using Android.Runtime;
using Firebase.Iid;
using PushDemo.Droid.Services;
using PushDemo.Services;

MainActivity.csで、LaunchMode を SingleTop に設定して、MainActivity を開いたときにもう一度作成されないようにします。

[Activity(
    Label = "PushDemo",
    LaunchMode = LaunchMode.SingleTop,
    Icon = "@mipmap/icon",
    Theme = "@style/MainTheme",
    MainLauncher = true,
    ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]

プライベートプロパティと対応するバッキングフィールドを追加して、IPushNotificationActionService への参照を格納し、IDeviceInstallationService 実装します。

IPushDemoNotificationActionService _notificationActionService;
IDeviceInstallationService _deviceInstallationService;

IPushDemoNotificationActionService NotificationActionService
    => _notificationActionService ??
        (_notificationActionService =
        ServiceContainer.Resolve<IPushDemoNotificationActionService>());

IDeviceInstallationService DeviceInstallationService
    => _deviceInstallationService ??
        (_deviceInstallationService =
        ServiceContainer.Resolve<IDeviceInstallationService>());

Firebase トークンを取得して格納するには、IOnSuccessListener インターフェイスを実装します。

public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity, Android.Gms.Tasks.IOnSuccessListener
{
    ...

    public void OnSuccess(Java.Lang.Object result)
        => DeviceInstallationService.Token =
            result.Class.GetMethod("getToken").Invoke(result).ToString();
}

ProcessNotificationActions という名前の新しいメソッドを追加します。このメソッドは、特定の意図にアクションという名前追加の値があるかどうかを確認します。 IPushDemoNotificationActionService 実装を使用して、そのアクションを条件付きでトリガーします。

void ProcessNotificationActions(Intent intent)
{
    try
    {
        if (intent?.HasExtra("action") == true)
        {
            var action = intent.GetStringExtra("action");

            if (!string.IsNullOrEmpty(action))
                NotificationActionService.TriggerAction(action);
        }
    }
    catch (Exception ex)
    {
        System.Diagnostics.Debug.WriteLine(ex.Message);
    }
}

OnNewIntent メソッドをオーバーライドして、ProcessNotificationActions メソッドを呼び出します。
```
protected override void OnNewIntent(Intent intent)
{
    base.OnNewIntent(intent);
    ProcessNotificationActions(intent);
}
```
手記

アクティビティの LaunchMode が SingleTopに設定されているため、インテントは、アクティビティの既存のインスタンスに送信されます。 OnNewIntent メソッドは、OnCreate メソッドではなく、OnCreate メソッドと onNewIntent メソッド両方で受信インテントを処理する必要があります。
IDeviceInstallationServiceのプラットフォーム固有の実装を渡す base.OnCreate の呼び出しの直後に Bootstrap.Begin を呼び出すように、OnCreate メソッドを更新します。
```
Bootstrap.Begin(() => new DeviceInstallationService());
```
同じメソッドで、FirebaseApp インスタンスで GetInstanceId を条件付きで呼び出し、の呼び出しの直後に、IOnSuccessListenerとして MainActivity 追加します。
```
if (DeviceInstallationService.NotificationsSupported)
{
    FirebaseInstanceId.GetInstance(Firebase.FirebaseApp.Instance)
        .GetInstanceId()
        .AddOnSuccessListener(this);
}
```
OnCreateでは、呼び出しの直後 ProcessNotificationActions を呼び出して、現在の インテントを渡 LoadApplication。
```
...

LoadApplication(new App());

ProcessNotificationActions(Intent);
```

手記

アプリを実行するたびに再登録し、デバッグセッションから停止してプッシュ通知の受信を続ける必要があります。

プッシュ通知用にネイティブ iOS プロジェクトを構成する

Info.plist と Entitlements.plist の構成

Visual StudioPreferences... Apple Developer Account にサインインしていることを確認します。Apple 開発者アカウント発行し、適切な証明書とプロビジョニングプロファイルがダウンロードされていることを確認します。これらの資産は、前の手順の一部として作成しておく必要があります。
PushDemo.iOSで、Info.plist 開き、BundleIdentifier が、Apple Developer Portalでそれぞれのプロビジョニングプロファイルに使用された値と一致していることを確認します。 BundleIdentifier は、com.<organization>.PushDemo形式でした。
同じファイルで、最小システムバージョン を 13.0に設定します。

手記

このチュートリアルでは、iOS 13.0 以降の実行されているデバイスのみがサポートされていますが、古いバージョンを実行しているデバイスをサポートするように拡張できます。
PushDemo.iOS の [プロジェクトオプション] 開きます (プロジェクトをダブルクリックします)。
[プロジェクトオプション]の [ビルド > iOS バンドル署名] の下にある [Teamで開発者アカウントが選択されていることを確認します。次に、[署名の自動管理] が選択され、署名証明書とプロビジョニングプロファイルが自動的に選択されていることを確認します。

手記

署名証明書のとプロビジョニングプロファイルが自動的に選択されていない場合は、[手動プロビジョニング選択し、[バンドル署名オプション]クリックします。 チーム が 署名 ID に選択され、PushDemo 固有のプロビジョニングプロファイルが、デバッグ 構成と リリース 構成の両方で プロビジョニングプロファイル に選択されていることを確認します。どちらの場合も、プラットフォーム に iPhone が選択されていることを確認します。
PushDemo.iOSで、Entitlements.plist 開き、[エンタイトルメント] タブで表示されたときに[プッシュ通知を有効にする] がオンになっていることを確認します。次に、[ソース] タブで表示するときに、APS 環境の設定が開発に設定されていることを確認します。

iOS のプッシュ通知を処理する

コントロールPushDemo.iOS プロジェクトのをクリックし、[ の追加] メニューから [新しいフォルダー ] を選択し、[フォルダー名]として [サービス] を使用して [ の追加] をクリックします。
コントロールServices フォルダーの [] をクリックし、[追加] メニューから [新しいファイル]... 選択します。

[全般][空のクラス]選択し、[名]に DeviceInstallationService.cs を入力し、[新規] クリック、次の実装を追加します。

using System;
using PushDemo.Models;
using PushDemo.Services;
using UIKit;

namespace PushDemo.iOS.Services
{
    public class DeviceInstallationService : IDeviceInstallationService
    {
        const int SupportedVersionMajor = 13;
        const int SupportedVersionMinor = 0;

        public string Token { get; set; }

        public bool NotificationsSupported
            => UIDevice.CurrentDevice.CheckSystemVersion(SupportedVersionMajor, SupportedVersionMinor);

        public string GetDeviceId()
            => UIDevice.CurrentDevice.IdentifierForVendor.ToString();

        public DeviceInstallation GetDeviceInstallation(params string[] tags)
        {
            if (!NotificationsSupported)
                throw new Exception(GetNotificationsSupportError());

            if (string.IsNullOrWhiteSpace(Token))
                throw new Exception("Unable to resolve token for APNS");

            var installation = new DeviceInstallation
            {
                InstallationId = GetDeviceId(),
                Platform = "apns",
                PushChannel = Token
            };

            installation.Tags.AddRange(tags);

            return installation;
        }

        string GetNotificationsSupportError()
        {
            if (!NotificationsSupported)
                return $"This app only supports notifications on iOS {SupportedVersionMajor}.{SupportedVersionMinor} and above. You are running {UIDevice.CurrentDevice.SystemVersion}.";

            if (Token == null)
                return $"This app can support notifications but you must enable this in your settings.";


            return "An error occurred preventing the use of push notifications";
        }
    }
}

手記

このクラスは、一意の ID (UIDevice.IdentifierForVendor 値を使用) と通知ハブ登録ペイロードを提供します。

Extensions という PushDemo.iOS プロジェクトに新しいフォルダーを追加、次の実装を使用して、NSDataExtensions.cs という名前の 空のクラス を追加します。

using System.Text;
using Foundation;

namespace PushDemo.iOS.Extensions
{
    internal static class NSDataExtensions
    {
        internal static string ToHexString(this NSData data)
        {
            var bytes = data.ToArray();

            if (bytes == null)
                return null;

            StringBuilder sb = new StringBuilder(bytes.Length * 2);

            foreach (byte b in bytes)
                sb.AppendFormat("{0:x2}", b);

            return sb.ToString().ToUpperInvariant();
        }
    }
}

AppDelegate.csで、次の名前空間がファイルの先頭に追加されていることを確認します。

using System;
using System.Diagnostics;
using System.Threading.Tasks;
using Foundation;
using PushDemo.iOS.Extensions;
using PushDemo.iOS.Services;
using PushDemo.Services;
using UIKit;
using UserNotifications;
using Xamarin.Essentials;

プライベートプロパティとそれに対応するバッキングフィールドを追加して、IPushDemoNotificationActionService 、INotificationRegistrationService、および IDeviceInstallationService 実装への参照を格納します。

IPushDemoNotificationActionService _notificationActionService;
INotificationRegistrationService _notificationRegistrationService;
IDeviceInstallationService _deviceInstallationService;

IPushDemoNotificationActionService NotificationActionService
    => _notificationActionService ??
        (_notificationActionService =
        ServiceContainer.Resolve<IPushDemoNotificationActionService>());

INotificationRegistrationService NotificationRegistrationService
    => _notificationRegistrationService ??
        (_notificationRegistrationService =
        ServiceContainer.Resolve<INotificationRegistrationService>());

IDeviceInstallationService DeviceInstallationService
    => _deviceInstallationService ??
        (_deviceInstallationService =
        ServiceContainer.Resolve<IDeviceInstallationService>());

RegisterForRemoteNotifications メソッドを追加してユーザー通知設定を登録し、APNSを使用してリモート通知を行います。

void RegisterForRemoteNotifications()
{
    MainThread.BeginInvokeOnMainThread(() =>
    {
        var pushSettings = UIUserNotificationSettings.GetSettingsForTypes(
            UIUserNotificationType.Alert |
            UIUserNotificationType.Badge |
            UIUserNotificationType.Sound,
            new NSSet());

        UIApplication.SharedApplication.RegisterUserNotificationSettings(pushSettings);
        UIApplication.SharedApplication.RegisterForRemoteNotifications();
    });
}

CompleteRegistrationAsync メソッドを追加して、IDeviceInstallationService.Token プロパティ値を設定します。登録を更新し、最後に保存されてから更新された場合は、デバイストークンをキャッシュします。
```
Task CompleteRegistrationAsync(NSData deviceToken)
{
    DeviceInstallationService.Token = deviceToken.ToHexString();
    return NotificationRegistrationService.RefreshRegistrationAsync();
}
```

NSDictionary 通知データを処理し、条件付きで NotificationActionService.TriggerActionを呼び出すための ProcessNotificationActions メソッド追加します。

void ProcessNotificationActions(NSDictionary userInfo)
{
    if (userInfo == null)
        return;

    try
    {
        var actionValue = userInfo.ObjectForKey(new NSString("action")) as NSString;

        if (!string.IsNullOrWhiteSpace(actionValue?.Description))
            NotificationActionService.TriggerAction(actionValue.Description);
    }
    catch (Exception ex)
    {
        Debug.WriteLine(ex.Message);
    }
}

deviceToken 引数を CompleteRegistrationAsync メソッドに渡す RegisteredForRemoteNotifications メソッドをオーバーライドします。

public override void RegisteredForRemoteNotifications(
    UIApplication application,
    NSData deviceToken)
    => CompleteRegistrationAsync(deviceToken).ContinueWith((task)
        => { if (task.IsFaulted) throw task.Exception; });

userInfo 引数を ProcessNotificationActions メソッドに渡す ReceivedRemoteNotification メソッドをオーバーライドします。

public override void ReceivedRemoteNotification(
    UIApplication application,
    NSDictionary userInfo)
    => ProcessNotificationActions(userInfo);

FailedToRegisterForRemoteNotifications メソッドをオーバーライドして、エラーをログに記録します。
```
public override void FailedToRegisterForRemoteNotifications(
    UIApplication application,
    NSError error)
    => Debug.WriteLine(error.Description);
```
手記

これは非常にプレースホルダーです。運用環境のシナリオでは、適切なログ記録とエラー処理を実装する必要があります。
IDeviceInstallationServiceのプラットフォーム固有の実装を渡す Forms.Init の呼び出しの直後に Bootstrap.Begin を呼び出すように、FinishedLaunching メソッドを更新します。
```
Bootstrap.Begin(() => new DeviceInstallationService());
```

同じ方法で、条件付きで承認を要求し、Bootstrap.Begin直後にリモート通知に登録します。

if (DeviceInstallationService.NotificationsSupported)
{
    UNUserNotificationCenter.Current.RequestAuthorization(
            UNAuthorizationOptions.Alert |
            UNAuthorizationOptions.Badge |
            UNAuthorizationOptions.Sound,
            (approvalGranted, error) =>
            {
                if (approvalGranted && error == null)
                    RegisterForRemoteNotifications();
            });
}

引き続き FinishedLaunchingで、オプション 引数に UIApplication.LaunchOptionsRemoteNotificationKey が含まれている場合、userInfo オブジェクトを渡 場合は、LoadApplication の呼び出しの直後に ProcessNotificationActions を呼び出します。
```
using (var userInfo = options?.ObjectForKey(
    UIApplication.LaunchOptionsRemoteNotificationKey) as NSDictionary)
        ProcessNotificationActions(userInfo);
```

ソリューションをテストする

バックエンドサービスを介した通知の送信をテストできるようになりました。

テスト通知を送信する

Postmanで新しいタブ開きます。
要求を POSTに設定し、次のアドレスを入力します。
```
https://<app_name>.azurewebsites.net/api/notifications/requests
```
API キーセクションを使用してクライアントを認証するを完了する場合は、apikey 値を含めるように要求ヘッダーを構成してください。

鍵価値

apikey <your_api_key>
Bodyの raw オプションを選択し、書式設定オプションの一覧から JSON 選択し、JSON コンテンツプレースホルダーを含めます。
```
{
    "text": "Message from Postman!",
    "action": "action_a"
}
```
ウィンドウの右上にある [ の保存] ボタンの下にある [Code] ボタンを選択します。要求は、HTML に対して表示される場合の次の例のようになります (apikey ヘッダーを含めたかどうかによって異なります)。
```
POST /api/notifications/requests HTTP/1.1
Host: https://<app_name>.azurewebsites.net
apikey: <your_api_key>
Content-Type: application/json

{
    "text": "Message from backend service",
    "action": "action_a"
}
```
PushDemo アプリケーションを、ターゲットプラットフォームの一方または両方 (Android と iOS) で実行します。

手記

Android でテスト、デバッグで実行されていないことを確認するか、アプリケーションを実行してアプリがデプロイされている場合は、アプリを強制的に閉じて起動ツールから再度起動します。
PushDemo アプリで、[Register] ボタンをタップします。
Postman戻り、[コードスニペットの生成] ウィンドウを閉じて (まだ行っていない場合)、[ の送信] ボタンをクリックします。
Postman で 200 OK 応答受け取り、アラートがアプリに表示され、受け取った ActionA アクション表示されていることを確認します。
PushDemo アプリを閉じ、Postmanでもう一度 [送信] ボタンクリックします。
Postman で 200 OK 応答返されることを検証します。正しいメッセージを含む PushDemo アプリの通知領域に通知が表示されることを確認します。
通知をタップしてアプリを開き、アラート受け取った ActionA アクションを表示したことを確認します。
Postman戻り、前の要求本文を変更して、アクションの値に action_a するのではなく、action_b を指定するサイレント通知を送信します。
```
{
    "action": "action_b",
    "silent": true
}
```
アプリを開いたまま、Postmanの [送信] ボタンクリックします。
Postman で 200 OK 応答を受け取り、受け取った ActionA アクションではなく、を受け取った ActionB アクション示すアラートアプリに表示されることを検証します。
PushDemo アプリを閉じ、Postmanでもう一度 [送信] ボタンクリックします。
Postman で 200 OK 応答受け取り、通知領域にサイレント通知が表示されないかどうかを検証します。

鍵	価値
apikey	<your_api_key>

トラブルシューティング

バックエンドサービスからの応答なし

ローカルでテストする場合は、バックエンドサービスが実行されており、正しいポートを使用していることを確認します。

Azure API Appに対してテストする場合は、サービスが実行中であり、デプロイされていて、エラーなしで開始されていることを確認します。

クライアント経由でテストする場合は、Postman またはモバイルアプリ構成ベースアドレスが正しく指定されていることを確認してください。ローカルでテストする場合は、ベースアドレスを https://<api_name>.azurewebsites.net/ または https://localhost:5001/ する必要があります。

デバッグセッションの開始または停止後に Android で通知を受信しない

デバッグセッションを開始または停止した後に、もう一度登録してください。デバッガーによって、新しい Firebase トークンが生成されます。通知ハブのインストールも更新する必要があります。

バックエンドサービスからの 401 状態コードの受信

apikey 要求ヘッダーを設定していることを確認します。この値は、バックエンドサービス用に構成したものと一致します。

ローカルでテストするときにこのエラーが発生した場合は、クライアント構成で定義したキー値が、APIで使用される Authentication:ApiKey ユーザー設定値と一致していることを確認します。

API アプリを使用してテストする場合は、クライアント構成ファイルのキー値が、API アプリで使用している Authentication:ApiKey アプリケーション設定と一致していることを確認します。

手記

バックエンドサービスをデプロイした後にこの設定を作成または変更した場合は、サービスを有効にするためにサービスを再起動する必要があります。

API キーセクションを使用してクライアントの認証を完了しないことを選択した場合は、NotificationsController クラスに Authorize 属性を適用していないことを確認します。

バックエンドサービスからの 404 状態コードの受信

エンドポイントと HTTP 要求メソッドが正しいことを検証します。たとえば、エンドポイントは次のように示す必要があります。

[PUT] をする
[DELETE]https://<api_name>.azurewebsites.net/api/notifications/installations/<installation_id>
[POST]https://<api_name>.azurewebsites.net/api/notifications/requests

または、ローカルでテストする場合:

[PUT] をする
[DELETE]https://localhost:5001/api/notifications/installations/<installation_id>
[POST]https://localhost:5001/api/notifications/requests

クライアントアプリでベースアドレスを指定するときは、/で終わることを確認します。ローカルでテストする場合は、ベースアドレスを https://<api_name>.azurewebsites.net/ または https://localhost:5001/ する必要があります。

登録できず、通知ハブのエラーメッセージが表示される

テストデバイスにネットワーク接続があることを確認します。次に、HttpResponseの StatusCode プロパティ値を検査するブレークポイントを設定して、Http 応答状態コードを決定します。

状態コードに基づいて、該当する場合は、前のトラブルシューティングの推奨事項を確認します。

それぞれの API に対してこれらの特定の状態コードを返す行にブレークポイントを設定します。次に、ローカルでデバッグするときにバックエンドサービスを呼び出してみてください。

適切なペイロードを使用 Postman を使用して、バックエンドサービスが期待どおりに動作していることを確認します。対象のプラットフォームのクライアントコードによって作成された実際のペイロードを使用します。

プラットフォーム固有の構成セクションを確認して、手順が実行されていないことを確認します。適切なプラットフォームの installation id 変数と token 変数に対して適切な値が解決されていることを確認します。

デバイスの ID を解決できないエラーメッセージが表示される

プラットフォーム固有の構成セクションを確認して、手順が実行されていないことを確認します。

Azure Notification Hubs の概要
Visual Studio for Mac のインストール
Windows への Xamarin のインストールの
バックエンド操作用の Notification Hubs SDK
GitHub で Notification Hubs SDK をする
アプリケーションバックエンドに登録する
登録管理
タグの操作
カスタムテンプレートの操作

次の手順

これで、基本的な Xamarin.Forms アプリがバックエンドサービス経由で通知ハブに接続され、通知を送受信できるようになります。

このチュートリアルで使用する例を独自のシナリオに合わせて調整する必要がある可能性があります。より堅牢なエラー処理、再試行ロジック、ログ記録の実装も推奨されます。

Visual Studio App Center は、トラブルシューティングに役立つ分析と診断を提供するモバイルアプリにすばやく組み込むことができます。

次の方法で共有

チュートリアル: バックエンド サービス経由で Azure Notification Hubs を使用して Xamarin.Forms アプリにプッシュ通知を送信する

前提 条件