Skip to content

プッシュ通知

プッシュ通知を使用すると、重要なイベントが発生したときにアプリから通知を送ることができます。新しいインスタントメッセージを配信したり、ニュース速報を送信したり、ユーザーのお気に入りのテレビ番組の最新エピソードがダウンロードしてオフライン視聴する準備ができたときに、プッシュ通知を送信することがあります。また、必要なときにのみアプリケーションが起動するため、バックグラウンドでの取得よりも効率的です。

前提条件

この機能を使用する前に、Web Braze SDKを統合する必要がある。

プッシュ・プロトコル

Web プッシュ通知は、大部分の主要ブラウザーでサポートされている W3C プッシュ標準を使用します。特定のプッシュ・プロトコルの標準やブラウザのサポートに関する詳細は、アップル社や モジラ社マイクロソフト社のリソースを参照されたい。

プッシュ通知の設定

ステップ 1: サービスワーカーを設定する

プロジェクトのservice-worker.js ファイルに以下のスニペットを追加し、Web SDKの初期化時に初期化オプションを に設定する。 manageServiceWorkerExternally初期化オプションをtrue に設定する。

ステップ 2:ブラウザを登録する

ブラウザがプッシュ通知を受け取れるように、ユーザーにプッシュ権限を即座に要求するには、braze.requestPushPermission() 。プッシュが相手のブラウザでサポートされているかどうかをテストするには、まずbraze.isPushSupported() に電話する。

また、プッシュ権限を要求する前にユーザーにソフトプッシュプロンプトを送り、独自のプッシュ関連UIを表示させることもできる。

ステップ 3:skipWaiting を無効にする(オプション)。

Brazeサービスワーカーファイルは、インストール時に自動的にskipWaiting 。この機能を無効にしたい場合は、Brazeをインポートした後、サービスワーカーファイルに以下のコードを追加する:

ユーザーの配信停止

ユーザーの配信停止は、braze.unregisterPush()

代替ドメイン

Web プッシュを統合するには、ドメインがセキュアである必要があります。一般にこれは、httpslocalhost、および W3C プッシュ標準で定義されているその他の例外である必要があります。また、ドメインのルートにサービスワーカーを登録するか、少なくともそのファイルの HTTP ヘッダーを制御できる必要もあります。この記事では、代替ドメイン上で Braze Web プッシュを統合する方法について説明します。

ユースケース

W3Cプッシュ標準に概説されている基準をすべて満たすことができない場合は、この方法を使用して、代わりにWebサイトにプッシュ・プロンプト・ダイアログを追加することができる。これは、http Webサイトやブラウザ拡張機能のポップアップがプッシュプロンプトの表示を妨げている場合に、ユーザーにオプトインさせたい場合に役立つ。

考慮事項

Web上の多くの回避策がそうであるように、ブラウザは絶えず進化しており、この方法は将来実行不可能になる可能性があることを覚えておいてほしい。続行する前に、以下を確認する:

  • あなたは別のセキュアドメイン(https:// )を所有し、そのドメインにサービスワーカーを登録する権限を持つ。
  • ユーザーはWebサイトにログインし、プッシュトークンが正しいプロファイルに一致することを確認する。

代替プッシュ・ドメインの設定

次の例をわかりやすくするために、訪問者を http://insecure.com でのプッシュに登録させることを目的として、http://insecure.comhttps://secure.com の2つのドメインを使用します。この例題は、ブラウザー拡張のポップアップページのchrome-extension://スキームにアプリ当てはまるかもしれません。

ステップ1:プロンプトフローを開始する

insecure.com で、URL パラメータを使用してセキュアドメインに新しいウィンドウを開封し、現在ログイン中のユーザーのBraze外部ID を渡します。

http://insecure.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<button id="opt-in">Opt-In For Push</button>
<script>
// the same ID you would use with `braze.changeUser`:
const user_id = getUserIdSomehow();
// pass the user ID into the secure domain URL:
const secure_url = `https://secure.com/push-registration.html?external_id=${user_id}`;

// when the user takes some action, open the secure URL in a new window
document.getElementById("opt-in").onclick = function(){
    if (!window.open(secure_url, 'Opt-In to Push', 'height=500,width=600,left=150,top=150')) {
        window.alert('The popup was blocked by your browser');
    } else {
        // user is shown a popup window
        // and you can now prompt for push in this window
    }
}
</script>

ステップ2:プッシュを登録する

この時点で、secure.com はポップアップウィンドウを開封します。ポップアップウィンドウでは、同じユーザー IDのBraze Web SDKを初期化し、Webプッシュに対するユーザーの権限をリクエストできます。

https://secure.com/push-registration.html

ステップ3:ドメイン間で通信する (オプション)

ユーザーは insecure.com から発生したこのワークフローからオプトインできるようになったため、ユーザーがすでにオプトインしているかどうかに基づいてサイトを変更できます。ユーザーがすでにプッシュを登録している場合、それを尋ねることに意味はありません。

iFrames と postMessage API を使用して、2つのドメイン間で通信できます。

insecure.com

insecure.com ドメインで、現在のユーザーのプッシュ登録に関する情報を (プッシュが_実際に_登録されている) セキュアドメインに問い合わせます。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!-- Create an iframe to the secure domain and run getPushStatus onload-->
<iframe id="push-status" src="https://secure.com/push-status.html" onload="getPushStatus()" style="display:none;"></iframe>

<script>
function getPushStatus(event){
    // send a message to the iframe asking for push status
    event.target.contentWindow.postMessage({type: 'get_push_status'}, 'https://secure.com');
    // listen for a response from the iframe's domain
    window.addEventListener("message", (event) => {
        if (event.origin === "http://insecure.com" && event.data.type === 'set_push_status') {
            // update the page based on the push permission we're told
            window.alert(`Is user registered for push? ${event.data.isPushPermissionGranted}`);
        }
    }   
}
</script>

secure.com/push-status.html

よくある質問(FAQ)

サービスワーカー

ルートディレクトリにサービスワーカーを登録できない場合は?

デフォルトでは、サービスワーカーは、それが登録されているのと同じディレクトリ内でのみ使用できる。たとえば、サービスワーカーファイルが /assets/service-worker.js に存在する場合、example.com/assets/*、または assets フォルダーのサブディレクトリー内にのみ登録でき、ホームページ (example.com/) には登録できません。このため、ルートディレクトリ (https://example.com/service-worker.js など) にサービスワーカーをホストして登録することをお勧めします。

ルートドメインにサービスワーカーを登録できない場合、別の方法として、サービスワーカーファイルを提供するときに Service-Worker-AllowedHTTP ヘッダを使うことである。サービスワーカーのレスポンスにService-Worker-Allowed: / を返すようにサーバーを設定することで、ブラウザにスコープを広げ、別のディレクトリから使用できるように指示する。

タグマネージャを使用してサービスワーカーを作成できますか?

いいえ、サービスワーカーは Web サイトのサーバーでホストされている必要があり、タグマネージャで読み込むことはできません。

サイトのセキュリティ

HTTPSは必要か?

はい。ウェブ標準は、プッシュ通知の許可を要求するドメインが安全であることを要求している。

サイトが「安全」とみなされるのはどのような場合か?

サイトが以下のsecure-originパターンのいずれかに一致する場合、そのサイトは安全であるとみなされる。BrazeのWebプッシュ通知は、この開封標準に基づいて構築されているため、中間者攻撃を防ぐことができる。

  • (https, , *)
  • (wss, *, *)
  • (, localhost, )
  • (, .localhost, *)
  • (, 127/8, )
  • (, ::1/128, *)
  • (file, *, —)
  • (chrome-extension, *, —)

安全なサイトが利用できない場合はどうするのか?

業界のベストプラクティスは、サイト全体をセキュアにすることですが、サイトドメインをセキュアにできない顧客は、セキュアなモーダルを使用して要件に対処できます。詳細については、代替プッシュドメインを使用するためのガイド、または作業デモを確認してください。

前提条件

この機能を使用する前に、Android Braze SDKを統合する必要がある。

内蔵機能

以下の機能は Braze Android SDK に組み込まれています。その他のプッシュ通知機能を利用するには、アプリ向けにプッシュ通知を設定する必要があります。

プッシュ通知のライフサイクルについて

以下のフローチャートは、Braze がプッシュ通知のライフサイクル(許可プロンプト、トークン生成、メッセージ配信など)をどのように処理するかを示しています。

---
config:
  theme: neutral
---
flowchart TD

%% Permission flow
subgraph Permission[Push Permissions]
    B{Android version of the device?}
    B -->|Android 13+| C["requestPushPermissionPrompt() called"]
    B -->|Android 12 and earlier| D[No permissions required]
    
    %% Connect Android 12 path to Braze state
    D --> H3[Braze: user subscription state]
    H3 --> J3[Defaults to 'subscribed' when user profile created]
    
    C --> E{Did the user grant push permission?}
    E -->|Yes| F[POST_NOTIFICATIONS permission granted]
    E -->|No| G[POST_NOTIFICATIONS permission denied]
    
    %% Braze subscription state updates
    F --> H1[Braze: user subscription state]
    G --> H2[Braze: user subscription state]
    
    H1 --> I1{Automatically opt in after permission granted?}
    I1 -->|true| J1[Set to 'opted-in']
    I1 -->|false| J2[Remains 'subscribed']
    
    H2 --> K1[Remains 'subscribed'<br/>or 'unsubscribed']
    
    %% Subscription state legend
    subgraph BrazeStates[Braze subscription states]
        L1['Subscribed' - default state<br/>when user profile created]
        L2['Opted-in' - user explicitly<br/>wants push notifications]
        L3['Unsubscribed' - user explicitly<br/>opted out of push]
    end
    
    %% Note about user-level states
    note1[Note: These states are user-level<br/>and apply across all devices for the user]
    
    %% Connect states to legend
    J1 -.-> L2
    J2 -.-> L1
    J3 -.-> L1
    K1 -.-> L3
    note1 -.-> BrazeStates
end

%% Styling
classDef permissionClass fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
classDef tokenClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px
classDef sdkClass fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef configClass fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef displayClass fill:#ffebee,stroke:#c62828,stroke-width:2px
classDef deliveryClass fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef brazeClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:3px

class A,B,C,E,F,G permissionClass
class H,I tokenClass
class J,K sdkClass
class N,O,P configClass
class R,S,S1,T,U,V displayClass
class W,X,X1,X2,Y,Z deliveryClass
class H1,H2,H3,I1,J1,J2,J3,K1,L1,L2,L3,note1 brazeClass
---
config:
  theme: neutral
---
flowchart TD

%% Token generation flow
subgraph Token[Token Generation]
    H["Braze SDK initialized"] --> Q{Is FCM auto-registration enabled?}
    Q -->|Yes| L{Is required configuration present?}
    Q -->|No| M[No FCM token generated]
    L -->|Yes| I[Generate FCM token]
    L -->|No| M
    I --> K[Register token with Braze]

    %% Configuration requirements
    subgraph Config[Required configuration]
        N['google-services.json' file is present]
        O['com.google.firebase:firebase-messaging' in gradle]
        P['com.google.gms.google-services' plugin in gradle]
    end

    %% Connect config to check
    N -.-> L
    O -.-> L
    P -.-> L
end

%% Styling
classDef permissionClass fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
classDef tokenClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px
classDef sdkClass fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef configClass fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef displayClass fill:#ffebee,stroke:#c62828,stroke-width:2px
classDef deliveryClass fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef brazeClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:3px

class A,B,C,E,F,G permissionClass
class H,I tokenClass
class J,K sdkClass
class N,O,P configClass
class R,S,S1,T,U,V displayClass
class W,X,X1,X2,Y,Z deliveryClass
class H1,H2,H3,I1,J1,J2,J3,K1,L1,L2,L3,note1 brazeClass
---
config:
  theme: neutral
  fontSize: 10
---
flowchart TD

subgraph Display[Push Display]
    %% Push delivery flow
    W[Push sent to FCM servers] --> X{Did FCM receive push?}
    X -->|App is terminated| Y[FCM cannot deliver push to the app]
    X -->|Delivery conditions met| X1[App receives push from FCM]
    X1 --> X2[Braze SDK receives push]
    X2 --> R[Push type?]

    %% Push Display Flow
    R -->|Standard push| S{Is push permission required?}
    R -->|Silent push| T[Braze SDK processes silent push]
    S -->|Yes| S1{Did the user grant push permission?}
    S -->|No| V[Notification is shown to the user]
    S1 -->|Yes| V
    S1 -->|No| U[Notification is not shown to the user]
end

%% Styling
classDef permissionClass fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
classDef tokenClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px
classDef sdkClass fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef configClass fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef displayClass fill:#ffebee,stroke:#c62828,stroke-width:2px
classDef deliveryClass fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef brazeClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:3px

class A,B,C,E,F,G permissionClass
class H,I tokenClass
class J,K sdkClass
class N,O,P configClass
class R,S,S1,T,U,V displayClass
class W,X,X1,X2,Y,Z deliveryClass
class H1,H2,H3,I1,J1,J2,J3,K1,L1,L2,L3,note1 brazeClass

プッシュ通知の設定

レート制限

Firebase Cloud Messaging(FCM)API には、1分あたり 600,000 リクエストというデフォルトのレート制限があります。この制限に達した場合、Braze は数分後に自動的に再試行します。引き上げをリクエストするには、Firebase サポートにお問い合わせください。

ステップ 1: Firebase をプロジェクトに追加する

まず、Firebase を Android プロジェクトに追加します。手順については、Google の Firebase セットアップガイドを参照してください。

ステップ 2: Cloud Messaging を依存関係に追加する

次に、Cloud Messaging ライブラリーをプロジェクトの依存関係に追加します。Android プロジェクトで build.gradle を開き、dependencies ブロックに次の行を追加します。

1
implementation "google.firebase:firebase-messaging:+"

依存関係は次のようになります。

1
2
3
4
dependencies {
  implementation project(':android-sdk-ui')
  implementation "com.google.firebase:firebase-messaging:+"
}

ステップ 3: Firebase Cloud Messaging API を有効にする

Google Cloud で、Android アプリが使用しているプロジェクトを選択し、Firebase Cloud Messaging API を有効にします。

有効化された Firebase Cloud Messaging API

ステップ 4: サービスアカウントを作成する

次に、新しいサービスアカウントを作成し、FCM トークンの登録時に Braze が許可された API 呼び出しを行えるようにします。Google Cloud で [サービスアカウント] に移動し、プロジェクトを選択します。[サービスアカウント] ページで [サービスアカウントの作成] を選択します。

プロジェクトのサービスアカウントのホームページで、「サービスアカウントを作成」が強調表示されている。

サービスアカウント名、ID、説明を入力して、[作成して続行] を選択します。

「サービスアカウントの詳細」のフォーム。

[ロール] フィールドで、ロールのリストから [Firebase Cloud Messaging API 管理者] を見つけて選択します。アクセスをより制限する場合は、cloudmessaging.messages.create 権限を持つカスタムロールを作成し、代わりにリストからそれを選択します。完了したら、[完了] を選択します。

「このサービスアカウントにプロジェクトへのアクセスを許可する」フォームで、「Firebase Cloud Messaging API 管理者」がロールとして選択されている。

ステップ 5: JSON 認証情報を生成する

次に、FCM サービスアカウントの JSON 認証情報を生成します。Google Cloud IAM & Admin で [サービスアカウント] に移動し、プロジェクトを選択します。先ほど作成した FCM サービスアカウントを見つけて、 [アクション] > [キーの管理] を選択します。

プロジェクトのサービスアカウントのホームページで、「アクション」メニューが開いている状態。

[キーの追加] > [新しいキーを作成] を選択します。

「キーを追加」メニューが開いている状態で選択されたサービスアカウント。

[JSON] を選択し、[作成] を選択します。FCM プロジェクト ID とは異なる Google Cloud プロジェクト ID を使用してサービスアカウントを作成した場合は、JSON ファイルで project_id に割り当てられた値を手動で更新する必要があります。

キーをどこにダウンロードしたかを覚えておいてください。次のステップで必要になります。

「JSON」を選択した状態で秘密キーを作成するフォーム。

ステップ 6: JSON の認証情報を Braze にアップロードする

次に、JSON 認証情報を Braze ダッシュボードにアップロードします。Braze で、 [設定] > [アプリの設定] を選択します。

「設定」メニューが Braze で開かれ、「アプリの設定」がハイライト表示されている。

Android アプリの [プッシュ通知設定] で [Firebase] を選択し、[JSON ファイルのアップロード] を選択して、先ほど生成した認証情報をアップロードします。完了したら、[保存] を選択します。

プッシュ通知プロバイダーとして「Firebase」が選択された「プッシュ通知設定」フォーム。

ステップ 7: トークンの自動登録を設定する

ユーザーがプッシュ通知をオプトインした場合、アプリはそのユーザーにプッシュ通知を送信する前に、ユーザーのデバイス上で FCM トークンを生成する必要があります。Braze SDK を使用すると、プロジェクトの Braze 設定ファイルで各ユーザーのデバイスの FCM トークン自動登録を有効にすることができます。

まず Firebase Console に移動し、プロジェクトを開いて、 [設定] > [プロジェクト設定] を選択します。

「設定」メニューが開いている Firebase プロジェクト。

[Cloud Messaging] を選択し、[Firebase Cloud Messaging API (V1)] で [送信者 ID] フィールドの数字をコピーします。

Firebase プロジェクトの「Cloud Messaging」ページで「送信者 ID」が強調表示されている。

次に、Android Studio プロジェクトを開き、Firebase 送信者 ID を使用して、braze.xml または BrazeConfig 内で FCM トークンの自動登録を有効にします。

FCM トークンの自動登録を設定するには、braze.xml ファイルに以下の行を追加します。

1
2
<bool translatable="false" name="com_braze_firebase_cloud_messaging_registration_enabled">true</bool>
<string translatable="false" name="com_braze_firebase_cloud_messaging_sender_id">FIREBASE_SENDER_ID</string>

FIREBASE_SENDER_ID を Firebase プロジェクトの設定からコピーした値に置き換えます。braze.xml は次のようになります。

1
2
3
4
5
6
<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string translatable="false" name="com_braze_api_key">12345ABC-6789-DEFG-0123-HIJK456789LM</string>
  <bool translatable="false" name="com_braze_firebase_cloud_messaging_registration_enabled">true</bool>
<string translatable="false" name="com_braze_firebase_cloud_messaging_sender_id">603679405392</string>
</resources>

FCM トークンの自動登録を設定するには、BrazeConfig に以下の行を追加します。

1
2
.setIsFirebaseCloudMessagingRegistrationEnabled(true)
.setFirebaseCloudMessagingSenderIdKey("FIREBASE_SENDER_ID")
1
2
.setIsFirebaseCloudMessagingRegistrationEnabled(true)
.setFirebaseCloudMessagingSenderIdKey("FIREBASE_SENDER_ID")

FIREBASE_SENDER_ID を Firebase プロジェクトの設定からコピーした値に置き換えます。BrazeConfig は次のようになります。

1
2
3
4
5
6
7
8
9
10
BrazeConfig brazeConfig = new BrazeConfig.Builder()
  .setApiKey("12345ABC-6789-DEFG-0123-HIJK456789LM")
  .setCustomEndpoint("sdk.iad-01.braze.com")
  .setSessionTimeout(60)
  .setHandlePushDeepLinksAutomatically(true)
  .setGreatNetworkDataFlushInterval(10)
  .setIsFirebaseCloudMessagingRegistrationEnabled(true)
  .setFirebaseCloudMessagingSenderIdKey("603679405392")
  .build();
Braze.configure(this, brazeConfig);
1
2
3
4
5
6
7
8
9
10
val brazeConfig = BrazeConfig.Builder()
  .setApiKey("12345ABC-6789-DEFG-0123-HIJK456789LM")
  .setCustomEndpoint("sdk.iad-01.braze.com")
  .setSessionTimeout(60)
  .setHandlePushDeepLinksAutomatically(true)
  .setGreatNetworkDataFlushInterval(10)
  .setIsFirebaseCloudMessagingRegistrationEnabled(true)
  .setFirebaseCloudMessagingSenderIdKey("603679405392")
  .build()
Braze.configure(this, brazeConfig)

ステップ 8: アプリケーションクラスの自動リクエストを削除する

サイレントプッシュ通知を送信するたびに Braze が不要なネットワークリクエストをトリガーするのを防ぐには、Application クラスの onCreate() メソッドで設定されている自動ネットワークリクエストをすべて削除してください。詳細については、Android 開発者リファレンス: Application を参照してください。

通知を表示する

ステップ 1: Braze Firebase メッセージングサービスを登録する

新規、既存、または Braze 以外の Firebase メッセージングサービスを作成できます。特定のニーズに最も合うものを選択してください。

Braze には、プッシュ受信インテントと開封インテントを処理するサービスが含まれています。BrazeFirebaseMessagingService クラスは AndroidManifest.xml に登録する必要があります。

1
2
3
4
5
6
<service android:name="com.braze.push.BrazeFirebaseMessagingService"
  android:exported="false">
  <intent-filter>
    <action android:name="com.google.firebase.MESSAGING_EVENT" />
  </intent-filter>
</service>

通知コードでは、BrazeFirebaseMessagingService を使用して、オープンアクションとクリックアクションのトラッキングも処理します。このサービスが正しく機能するには、AndroidManifest.xml に登録する必要があります。また、Braze はシステムからの通知に固有のキーをプレフィックスとして付加するため、Braze のシステムから送信された通知のみをレンダリングします。他の FCM サービスから送信される通知を表示するために、追加のサービスを個別に登録することもできます。Firebase プッシュサンプルアプリの AndroidManifest.xml を参照してください。

Firebase Messaging Service がすでに登録されている場合は、RemoteMessage オブジェクトを BrazeFirebaseMessagingService.handleBrazeRemoteMessage() 経由で Braze に渡すことができます。このメソッドは RemoteMessage オブジェクトが Braze から発信された場合にのみ通知を表示し、そうでない場合は安全に無視します。

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MyFirebaseMessagingService extends FirebaseMessagingService {
  @Override
  public void onMessageReceived(RemoteMessage remoteMessage) {
    super.onMessageReceived(remoteMessage);
    if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
      // This Remote Message originated from Braze and a push notification was displayed.
      // No further action is needed.
    } else {
      // This Remote Message did not originate from Braze.
      // No action was taken and you can safely pass this Remote Message to other handlers.
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
class MyFirebaseMessagingService : FirebaseMessagingService() {
  override fun onMessageReceived(remoteMessage: RemoteMessage?) {
    super.onMessageReceived(remoteMessage)
    if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
      // This Remote Message originated from Braze and a push notification was displayed.
      // No further action is needed.
    } else {
      // This Remote Message did not originate from Braze.
      // No action was taken and you can safely pass this Remote Message to other handlers.
    }
  }
}

使用したい別の Firebase メッセージングサービスがある場合は、アプリケーションが Braze からではないプッシュを受信した場合に呼び出すフォールバック Firebase メッセージングサービスを指定することもできます。

braze.xml で次のように指定します。

1
2
<bool name="com_braze_fallback_firebase_cloud_messaging_service_enabled">true</bool>
<string name="com_braze_fallback_firebase_cloud_messaging_service_classpath">com.company.OurFirebaseMessagingService</string>

または、ランタイム設定で設定します。

1
2
3
4
5
BrazeConfig brazeConfig = new BrazeConfig.Builder()
        .setFallbackFirebaseMessagingServiceEnabled(true)
        .setFallbackFirebaseMessagingServiceClasspath("com.company.OurFirebaseMessagingService")
        .build();
Braze.configure(this, brazeConfig);
1
2
3
4
5
val brazeConfig = BrazeConfig.Builder()
        .setFallbackFirebaseMessagingServiceEnabled(true)
        .setFallbackFirebaseMessagingServiceClasspath("com.company.OurFirebaseMessagingService")
        .build()
Braze.configure(this, brazeConfig)

ステップ 2: 小さなアイコンをデザインガイドラインに準拠させる

Android 通知アイコンの一般的な情報については、通知の概要をご覧ください。

Android N 以降、色を使った小さな通知アイコンアセットは更新または削除する必要があります。Android システム(Braze SDK ではない)は、アクションアイコンと小さな通知アイコンの非アルファチャネルと透明チャネルをすべて無視します。つまり、Android は小さな通知アイコンの透明領域を除くすべての部分をモノクロに変換します。

正しく表示される通知用小さなアイコンアセットを作成するには:

  • 画像から白以外のすべての色を削除します。
  • アセットの他のすべての非白色領域は透明にする必要があります。

次の図の大小アイコンは、適切にデザインされたアイコンの例です。

大きなアイコンの隅に小さなアイコンが表示され、その横に「Hey I'm on my way to the bar but..」というメッセージが表示されている

ステップ 3: 通知アイコンを設定する

braze.xml でアイコンを指定する

Braze では、braze.xml 内で drawable リソースを指定することで、通知アイコンを設定できます。

1
2
<drawable name="com_braze_push_small_notification_icon">REPLACE_WITH_YOUR_ICON</drawable>
<drawable name="com_braze_push_large_notification_icon">REPLACE_WITH_YOUR_ICON</drawable>

小さな通知アイコンの設定は必須です。設定しない場合、Braze はデフォルトでアプリケーションアイコンを小さな通知アイコンとして使用しますが、最適に表示されない可能性があります。

大きな通知アイコンの設定は任意ですが、推奨されます。

アイコンのアクセントカラーを指定する

通知アイコンのアクセントカラーは、braze.xml でオーバーライドできます。色を指定しない場合、デフォルトの色は Lollipop がシステム通知に使用するのと同じグレーになります。

1
<integer name="com_braze_default_notification_accent_color">0xFFf33e3e</integer>

オプションでカラーリファレンスを使用することもできます。

1
<color name="com_braze_default_notification_accent_color">@color/my_color_here</color>

ステップ 4: ディープリンクを追加する

ディープリンクの自動オープンを有効にする

プッシュ通知がクリックされたときに Braze がアプリとディープリンクを自動的に開くようにするには、braze.xmlcom_braze_handle_push_deep_links_automaticallytrue に設定します。

1
<bool name="com_braze_handle_push_deep_links_automatically">true</bool>

このフラグは、ランタイム設定で設定することもできます。

1
2
3
4
BrazeConfig brazeConfig = new BrazeConfig.Builder()
        .setHandlePushDeepLinksAutomatically(true)
        .build();
Braze.configure(this, brazeConfig);
1
2
3
4
val brazeConfig = BrazeConfig.Builder()
        .setHandlePushDeepLinksAutomatically(true)
        .build()
Braze.configure(this, brazeConfig)

ディープリンクをカスタムで処理する場合は、Braze からのプッシュ受信およびオープンインテントをリッスンするプッシュコールバックを作成する必要があります。詳細については、プッシュイベントのコールバックの使用を参照してください。

フォアグラウンド通知の処理

Android では、アプリがフォアグラウンドにあるときにプッシュ通知が届くと、デフォルトでシステムが自動的に表示します。Braze にプッシュ通知のペイロードを処理させる場合(分析トラッキング、ディープリンク処理、カスタム処理のため)、FirebaseMessagingService.onMessageReceived メソッド内で受信したプッシュデータを Braze にルーティングしてください。

仕組み

BrazeFirebaseMessagingService.handleBrazeRemoteMessage を呼び出すと、Braze はペイロードが Braze プッシュ通知かどうかを判断し、該当する場合は NotificationManagerCompat メソッドで通知を作成して表示します。iOS とは異なり、Android はアプリがフォアグラウンドにあるかバックグラウンドにあるかを問わず通知を表示します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.example.push;

import com.braze.push.BrazeFirebaseMessagingService;
import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;

public class MyFirebaseMessagingService extends FirebaseMessagingService {
    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        super.onMessageReceived(remoteMessage);
        
        // Let Braze process the payload and display the notification
        if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
            // Braze successfully handled the push notification
        } else {
            // Handle non-Braze messages
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.example.push

import com.braze.push.BrazeFirebaseMessagingService
import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage

class MyFirebaseMessagingService : FirebaseMessagingService() {
    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        super.onMessageReceived(remoteMessage)
        
        // Let Braze process the payload and display the notification
        if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
            // Braze successfully handled the push notification
        } else {
            // Handle non-Braze messages
        }
    }
}

詳細については、Braze Android SDK リポジトリ内の Firebase 統合サンプルを参照してください。

フォアグラウンド動作のカスタマイズ

カスタムのフォアグラウンド動作を実装したい場合(システム通知を抑制したり、代わりにアプリ内 UI を表示したりするなど)、以下の方法があります。

  • subscribeToPushNotificationEvents を使用してプッシュイベントに反応し、BrazeNotificationUtils.routeUserWithNotificationOpenedIntent メソッドでディープリンクを処理します。詳細については、Firebase プッシュサンプルを参照してください。
  • カスタムの IBrazeNotificationFactory を使用して独自の通知を構築して投稿するか、処理パスで notificationManager.notify を呼び出さないことで通知を抑制します。

通知のカスタマイズに関する詳細は、カスタム通知ファクトリを参照してください。

カスタムディープリンクの作成

アプリにまだディープリンクを追加していない場合は、Android 開発者ドキュメントに記載されているディープリンクに関する手順に従ってください。ディープリンクの詳細については、FAQ の記事を参照してください。

ディープリンクの追加

Braze ダッシュボードは、通知がクリックされたときに開くプッシュ通知キャンペーンとキャンバスでのディープリンクまたは Web URL の設定をサポートしています。

Braze ダッシュボードの「クリック時の動作」設定で、ドロップダウンから「アプリケーションへのディープリンク」を選択している状態。

バックスタック動作のカスタマイズ

Android SDK のデフォルトでは、プッシュのディープリンクを辿ると、ホストアプリのメインのランチャーアクティビティがバックスタックに配置されます。Braze では、メインのランチャーアクティビティの代わりにバックスタックで開くカスタムアクティビティを設定したり、バックスタックを完全に無効にしたりすることができます。

たとえば、ランタイム設定を使用して、YourMainActivity というアクティビティをバックスタックアクティビティとして設定するには、次のようにします。

1
2
3
4
5
BrazeConfig brazeConfig = new BrazeConfig.Builder()
        .setPushDeepLinkBackStackActivityEnabled(true)
        .setPushDeepLinkBackStackActivityClass(YourMainActivity.class)
        .build();
Braze.configure(this, brazeConfig);
1
2
3
4
5
val brazeConfig = BrazeConfig.Builder()
        .setPushDeepLinkBackStackActivityEnabled(true)
        .setPushDeepLinkBackStackActivityClass(YourMainActivity.class)
        .build()
Braze.configure(this, brazeConfig)

braze.xml の同等の設定を参照してください。クラス名は Class.forName() で返されるものと同じでなければならないことに注意してください。

1
2
<bool name="com_braze_push_deep_link_back_stack_activity_enabled">true</bool>
<string name="com_braze_push_deep_link_back_stack_activity_class_name">your.package.name.YourMainActivity</string>

ステップ 5: 通知チャネルを定義する

Braze Android SDK は Android 通知チャネルをサポートしています。Braze の通知に通知チャネルの ID が含まれていない場合、または Braze の通知に無効なチャネル ID が含まれている場合、Braze は SDK で定義されているデフォルトの通知チャネルで通知を表示します。Braze ユーザーはプラットフォーム内で Android 通知チャネルを使用して通知をグループ化します。

デフォルトの Braze 通知チャネルのユーザー向けの名前を設定するには、BrazeConfig.setDefaultNotificationChannelName() を使用します。

デフォルトの Braze 通知チャネルのユーザー向けの説明を設定するには、BrazeConfig.setDefaultNotificationChannelDescription() を使用します。

Android プッシュオブジェクトパラメータを使用して API キャンペーンを更新し、notification_channel フィールドを含めます。このフィールドが指定されていない場合、Braze はダッシュボードフォールバックチャネル ID を持つ通知ペイロードを送信します。

デフォルトの通知チャネル以外、Braze はチャネルを作成しません。他のすべてのチャネルは、ホストアプリでプログラムで定義してから、Braze ダッシュボードに入力する必要があります。

デフォルトのチャネル名と説明も braze.xml で設定できます。

1
2
<string name="com_braze_default_notification_channel_name">Your channel name</string>
<string name="com_braze_default_notification_channel_description">Your channel description</string>

ステップ 6: 通知の表示と分析をテストする

表示のテスト

この時点で、Braze から送信された通知を表示できるはずです。これをテストするには、Braze ダッシュボードの [キャンペーン] ページにアクセスし、プッシュ通知キャンペーンを作成します。[Android プッシュ] を選択し、メッセージをデザインします。次に、作成画面で目のアイコンをクリックしてテスト送信者を取得します。現在のユーザーのユーザー ID またはメールアドレスを入力し、[テストを送信] をクリックします。デバイスにプッシュが表示されます。

Braze ダッシュボード内のプッシュ通知キャンペーンの「テスト」タブ。

プッシュ表示に関する問題については、トラブルシューティングガイドを参照してください。

分析のテスト

この時点で、プッシュ通知の開封に関する分析ログも記録されているはずです。届いた通知をクリックすると、キャンペーン結果ページの [直接開封数] の値が 1 増えます。プッシュ分析の内訳については、プッシュレポートの記事をご覧ください。

プッシュ分析に関する問題については、トラブルシューティングガイドを参照してください。

コマンドラインからのテスト

コマンドラインインターフェイスを介してアプリ内通知とプッシュ通知をテストする場合は、cURL とメッセージング API を介してターミナルから単一の通知を送信できます。次のフィールドをテストケースの正しい値に置き換える必要があります。

  • YOUR_API_KEY([設定] > [API キー] に移動)
  • YOUR_EXTERNAL_USER_ID([ユーザーを検索] ページでプロファイルを検索)
  • YOUR_KEY1(省略可能)
  • YOUR_VALUE1(省略可能)
1
2
3
4
5
6
7
8
9
10
11
12
curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer {YOUR_API_KEY}" -d '{
  "external_user_ids":["YOUR_EXTERNAL_USER_ID"],
  "messages": {
    "android_push": {
      "title":"Test push title",
      "alert":"Test push",
      "extra": {
        "YOUR_KEY1":"YOUR_VALUE1"
      }
    }  
  }
}' https://rest.iad-01.braze.com/messages/send

この例では、US-01 インスタンスを使用しています。このインスタンスを使用していない場合は、US-01 エンドポイントを自分のエンドポイントに置き換えてください。

会話プッシュ通知

人と会話のイニシアチブは、スマートフォンのシステムサーフェスで人との会話を向上させることを目的とした、複数年にわたる Android の取り組みです。この優先順位は、他のユーザーとのコミュニケーションや対話が、あらゆるユーザー層にわたる大多数の Android ユーザーにとって、依然として最も価値のある重要な機能分野であるという事実に基づいています。

使用要件

  • この通知タイプには、Braze Android SDK v15.0.0 以降と Android 11 以降のデバイスが必要です。
  • サポートされていないデバイスや SDK は、標準のプッシュ通知にフォールバックします。

この機能は Braze REST API 経由でのみ利用できます。詳細については、Android プッシュオブジェクトを参照してください。

FCM のクォータ超過エラー

Firebase Cloud Messaging(FCM)の制限を超過すると、Google は「クォータ超過」エラーを返します。FCM のデフォルトの制限は、1分あたり 600,000 リクエストです。Braze は Google が推奨するベストプラクティスに従って送信を再試行します。しかし、こうしたエラーが大量に発生すると、送信時間が数分間長引くことがあります。潜在的な影響を軽減するために、Braze はレート制限を超えていることを示すアラートと、エラーを防ぐために実行できるステップを送信します。

現在の制限を確認するには、Google Cloud コンソール > API とサービス > Firebase Cloud Messaging API > クォータとシステム制限に移動するか、FCM API クォータのページにアクセスしてください。

ベストプラクティス

これらのエラー発生量を低く抑えるために、以下のベストプラクティスを推奨します。

FCM にレート制限の引き上げをリクエストする

FCM のレート制限の引き上げをリクエストするには、Firebase サポートに直接連絡するか、以下の手順を実行します。

  1. FCM API のクォータページに移動します。
  2. 1分あたりのリクエスト送信クォータを確認します。
  3. クォータの編集を選択します。
  4. 新しい値を入力し、リクエストを送信します。

ワークスペースのレート制限を適用する

Android プッシュ通知にワークスペースのレート制限を適用できます。これにより、送信メッセージの配信レートを調整できます。詳細については、ワークスペースのメッセージングレート制限を参照してください。

レート制限

プッシュ通知にはレート制限があるため、アプリケーションで必要なだけ送信しても構いません。iOS と Apple Push Notification service (APNs) サーバーが配信頻度を制御するため、送信しすぎても問題が発生することはありません。プッシュ通知がスロットリングされている場合、デバイスが次にキープアライブパケットを送信するか、別の通知を受信するまで遅延する可能性があります。

プッシュ通知の設定

ステップ 1: APN トークンをアップロードする

Brazeを使ってiOSプッシュ通知を送信する前に、Appleの開発者向けドキュメントに記載されているように、.p8 プッシュ通知ファイルをアップロードする必要がある:

  1. Apple 開発者アカウントで、以下にアクセスする。 証明書、識別子& プロファイル.
  2. [キー] で [すべて] を選択し、右上の追加ボタン (+) をクリックします。
  3. [キーの説明]で、署名キーの一意の名前を入力します。
  4. [キーサービス] で [Apple プッシュ通知サービス (APNs)] チェックボックスをオンにし、[続行] をクリックします。[確認] をクリックします。
  5. キー ID をメモしておきます。[ダウンロード] をクリックして、キーを生成してダウンロードします。ダウンロードしたファイルは、何度もダウンロードできませんので、安全な場所に保存してください。
  6. Braze で、[設定] > [アプリ設定] に移動し、[Apple プッシュ通知証明書] で .p8 ファイルをアップロードします。開発用または実稼働用のプッシュ証明書のいずれかをアップロードできます。アプリが App Store で公開された後にプッシュ通知をテストするには、アプリの開発バージョン用に別のワークスペースを設定することをお勧めします。
  7. プロンプトが表示されたら、アプリのバンドルIDキーIDチームIDを入力する。また、アプリの開発環境と本番環境のどちらに通知を送るかを指定する必要があるが、これはアプリのプロビジョニング・プロファイルによって定義される。
  8. 完了したら、[保存] を選択します。

ステップ2:プッシュ機能を有効にする

Xcodeで、メインアプリのターゲットの「&署名機能」セクションに移動し、プッシュ通知機能を追加する。

Xcodeプロジェクト内の「署名&機能」セクション。

ステップ 3:プッシュ処理を設定する

Swift SDKを使って、Brazeから受信したリモート通知の処理をオートメーションできる。これがプッシュ通知を扱う最も簡単な方法であり、推奨される処理方法である。

ステップ 3.1:プッシュプロパティでオートメーションを有効にする

自動プッシュ統合を有効にするには、push 設定のautomation プロパティをtrue に設定する:

1
2
let configuration = Braze.Configuration(apiKey: "{YOUR-BRAZE-API-KEY}", endpoint: "{YOUR-BRAZE-API-ENDPOINT}")
configuration.push.automation = true
1
2
BRZConfiguration *configuration = [[BRZConfiguration alloc] initWithApiKey:@"{YOUR-BRAZE-API-KEY}" endpoint:@"{YOUR-BRAZE-API-ENDPOINT}"];
configuration.push.automation = [[BRZConfigurationPushAutomation alloc] initEnablingAllAutomations:YES];

これにより、SDK に次のことが指示されます。

  • プッシュ通知用のアプリケーションをシステムに登録する。
  • 初期化時にプッシュ通知の認証/許可を要求する。
  • プッシュ通知関連のシステム・デリゲート・メソッドの実装を動的に提供する。

ステップ 3.2:個別の設定を上書きする(任意)

よりきめ細かいコントロールのために、各オートメーションステップを個別に有効または無効にすることができます

1
2
3
// Enable all automations and disable the automatic notification authorization request at launch.
configuration.push.automation = true
configuration.push.automation.requestAuthorizationAtLaunch = false
1
2
3
// Enable all automations and disable the automatic notification authorization request at launch.
configuration.push.automation = [[BRZConfigurationPushAutomation alloc] initEnablingAllAutomations:YES];
configuration.push.automation.requestAuthorizationAtLaunch = NO;

使用可能なすべてのオプションについては Braze.Configuration.Push.Automation を、オートメーション動作の詳細については automation を参照してください。

ステップ 3.1:APNでプッシュ通知に登録する

ユーザーのデバイスがAPNに登録できるように、アプリのapplication:didFinishLaunchingWithOptions: デリゲート・メソッド内に適切なコード・サンプルを含める。アプリケーションのメインスレッドですべてのプッシュ統合コードを呼び出すようにしてください。

Braze には、プッシュアクションボタンをサポートするデフォルトのプッシュカテゴリーも用意されており、プッシュ登録コードに手動で追加する必要があります。その他の統合ステップについては、プッシュアクションボタンを参照のこと。

アプリのデリゲートのapplication:didFinishLaunchingWithOptions: メソッドに以下のコードを追加する。

1
2
3
4
5
6
7
8
9
10
11
application.registerForRemoteNotifications()
let center = UNUserNotificationCenter.current()
center.setNotificationCategories(Braze.Notifications.categories)
center.delegate = self
var options: UNAuthorizationOptions = [.alert, .sound, .badge]
if #available(iOS 12.0, *) {
  options = UNAuthorizationOptions(rawValue: options.rawValue | UNAuthorizationOptions.provisional.rawValue)
}
center.requestAuthorization(options: options) { granted, error in
  print("Notification authorization, granted: \(granted), error: \(String(describing: error))")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
[application registerForRemoteNotifications];
UNUserNotificationCenter *center = UNUserNotificationCenter.currentNotificationCenter;
[center setNotificationCategories:BRZNotifications.categories];
center.delegate = self;
UNAuthorizationOptions options = UNAuthorizationOptionAlert | UNAuthorizationOptionSound | UNAuthorizationOptionBadge;
if (@available(iOS 12.0, *)) {
  options = options | UNAuthorizationOptionProvisional;
}
[center requestAuthorizationWithOptions:options
                      completionHandler:^(BOOL granted, NSError *_Nullable error) {
                        NSLog(@"Notification authorization, granted: %d, "
                              @"error: %@)",
                              granted, error);
}];

ステップ 3.2:Braze にプッシュトークンを登録する

APNの登録が完了したら、結果のdeviceToken をBrazeに渡し、ユーザーのプッシュ通知を有効にする。

アプリの application(_:didRegisterForRemoteNotificationsWithDeviceToken:) メソッドに次のコードを追加します。

1
AppDelegate.braze?.notifications.register(deviceToken: deviceToken)

アプリの application:didRegisterForRemoteNotificationsWithDeviceToken: メソッドに次のコードを追加します。

1
[AppDelegate.braze.notifications registerDeviceToken:deviceToken];

ステップ3.3:プッシュ処理を有効にする

次に、受信したプッシュ通知をBrazeに渡す。このステップは、プッシュ分析とリンク処理のロギングに必要である。アプリケーションのメインスレッドですべてのプッシュ統合コードを呼び出すようにしてください。

デフォルトのプッシュ処理

Brazeのデフォルトプッシュ処理をイネーブルメントするには、アプリの`onPushapplication(_:didReceiveRemoteNotification:fetchCompletionHandler:)`メソッドに以下のコードを追加する:

1
2
3
4
5
6
7
if let braze = AppDelegate.braze, braze.notifications.handleBackgroundNotification(
  userInfo: userInfo,
  fetchCompletionHandler: completionHandler
) {
  return
}
completionHandler(.noData)

次に、アプリの userNotificationCenter(_:didReceive:withCompletionHandler:) メソッドに以下を追加します。

1
2
3
4
5
6
7
if let braze = AppDelegate.braze, braze.notifications.handleUserNotification(
  response: response,
  withCompletionHandler: completionHandler
) {
  return
}
completionHandler()

Brazeのデフォルトプッシュ処理のイネーブルメントを行うには、アプリケーションの`onPushapplication:didReceiveRemoteNotification:fetchCompletionHandler:`メソッドに以下のコードを追加する:

1
2
3
4
5
6
7
BOOL processedByBraze = AppDelegate.braze != nil && [AppDelegate.braze.notifications handleBackgroundNotificationWithUserInfo:userInfo
                                                                                                       fetchCompletionHandler:completionHandler];
if (processedByBraze) {
  return;
}

completionHandler(UIBackgroundFetchResultNoData);

次に、アプリの (void)userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler: メソッドに次のコードを追加します。

1
2
3
4
5
6
7
BOOL processedByBraze = AppDelegate.braze != nil && [AppDelegate.braze.notifications handleUserNotificationWithResponse:response
                                                                                                  withCompletionHandler:completionHandler];
if (processedByBraze) {
  return;
}

completionHandler();
フォアグラウンドでのプッシュ通知処理

フォアグラウンドのプッシュ通知を有効にし、受信時に Braze がそれを認識できるようにするには、UNUserNotificationCenter.userNotificationCenter(_:willPresent:withCompletionHandler:) を実装します。ユーザーがフォアグラウンド通知をタップすると、userNotificationCenter(_:didReceive:withCompletionHandler:) プッシュデリゲートが呼び出され、Brazeはプッシュクリックイベントを記録する。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func userNotificationCenter(
  _ center: UNUserNotificationCenter,
  willPresent notification: UNNotification,
  withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions
) -> Void) {
  if let braze = AppDelegate.braze {
    // Forward notification payload to Braze for processing.
    braze.notifications.handleForegroundNotification(notification: notification)
  }

  // Configure application's foreground notification display options.
  if #available(iOS 14.0, *) {
    completionHandler([.list, .banner])
  } else {
    completionHandler([.alert])
  }
}

フォアグラウンドのプッシュ通知を有効にし、受信時に Braze がそれを認識できるようにするには、userNotificationCenter:willPresentNotification:withCompletionHandler: を実装します。ユーザーがフォアグラウンド通知をタップすると、userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler: プッシュデリゲートが呼び出され、Brazeはプッシュクリックイベントを記録する。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
- (void)userNotificationCenter:(UNUserNotificationCenter *)center
       willPresentNotification:(UNNotification *)notification
         withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler {
  if (AppDelegate.braze != nil) {
    // Forward notification payload to Braze for processing.
    [AppDelegate.braze.notifications handleForegroundNotificationWithNotification:notification];
  }

  // Configure application's foreground notification display options.
  if (@available(iOS 14.0, *)) {
    completionHandler(UNNotificationPresentationOptionList | UNNotificationPresentationOptionBanner);
  } else {
    completionHandler(UNNotificationPresentationOptionAlert);
  }
}

通知のテスト

コマンドラインからアプリ内通知とプッシュ通知をテストする場合は、CURL とメッセージング API を介してターミナルから単一の通知を送信できます。次のフィールドをテストケースの正しい値に置き換える必要があります。

  • YOUR_API_KEY - [設定] > [API キー] で利用できます。
  • YOUR_EXTERNAL_USER_ID - [ユーザーの検索] ページで使用できます。詳しくはユーザーIDの割り当てを参照のこと。
  • YOUR_KEY1 (省略可能)
  • YOUR_VALUE1 (省略可能)

以下の例では、US-01 インスタンスを使用している。このインスタンスを使用していない場合は、APIドキュメントを参照して、どのエンドポイントにリクエストを行うかを確認すること。

1
2
3
4
5
6
7
8
9
10
11
curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer {YOUR_API_KEY}" -d '{
  "external_user_ids":["YOUR_EXTERNAL_USER_ID"],
  "messages": {
    "apple_push": {
      "alert":"Test push",
      "extra": {
        "YOUR_KEY1":"YOUR_VALUE1"
      }
    }
  }
}' https://rest.iad-01.braze.com/messages/send

プッシュ通知更新を購読する

Brazeが処理するプッシュ通知ペイロードにアクセスするには Braze.Notifications.subscribeToUpdates(payloadTypes:_:)メソッドを使う。

payloadTypes パラメーターを使用して、プッシュ開封イベント、プッシュ受信イベント、またはその両方を含む通知を購読するかどうかを指定できます。

1
2
3
4
5
6
// This subscription is maintained through a Braze cancellable, which will observe for changes until the subscription is cancelled.
// You must keep a strong reference to the cancellable to keep the subscription active.
// The subscription is canceled either when the cancellable is deinitialized or when you call its `.cancel()` method.
let cancellable = AppDelegate.braze?.notifications.subscribeToUpdates(payloadTypes: [.open, .received]) { payload in
  print("Braze processed notification with title '\(payload.title)' and body '\(payload.body)'")
}
1
2
3
4
5
NSInteger filtersValue = BRZNotificationsPayloadTypeFilter.opened.rawValue | BRZNotificationsPayloadTypeFilter.received.rawValue;
BRZNotificationsPayloadTypeFilter *filters = [[BRZNotificationsPayloadTypeFilter alloc] initWithRawValue: filtersValue];
BRZCancellable *cancellable = [notifications subscribeToUpdatesWithPayloadTypes:filters update:^(BRZNotificationsPayload * _Nonnull payload) {
  NSLog(@"Braze processed notification with title '%@' and body '%@'", payload.title, payload.body);
}];

フォアグラウンド通知の処理

デフォルトでは、アプリがフォアグラウンドにあるときにプッシュ通知が届いても、iOSは自動的に表示しない。プッシュ通知をフォアグラウンドで表示し、Braze分析でトラッキングを行うには、実装UNUserNotificationCenterDelegate.userNotificationCenter(_:willPresent:withCompletionHandler:)内のメソッドhandleForegroundNotification(notification:)を呼び出す。

仕組み

通知を送信するとhandleForegroundNotification(notification:)、Brazeは通知ペイロードを処理して分析データを記録し、ディープリンクやボタンアクションを処理する。実際の表示動作は、完了ハンドラに渡すUNNotificationPresentationOptions引数によってコントロールされる。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import BrazeKit
import UserNotifications

extension AppDelegate: UNUserNotificationCenterDelegate {
  func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    willPresent notification: UNNotification,
    withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
  ) {
    // Let Braze process the notification payload
    if let braze = AppDelegate.braze {
      braze.notifications.handleForegroundNotification(notification: notification)
    }
    
    // Control how the notification appears in the foreground
    if #available(iOS 14.0, *) {
      completionHandler([.banner, .list, .sound])
    } else {
      completionHandler([.alert, .sound])
    }
  }
}

完全な例については、Braze SWIFT SDKリポジトリ内のプッシュ通知マニュアル統合サンプルを参照せよ。

プッシュプライマー

プッシュプライマーキャンペーンでは、アプリのデバイスでプッシュ通知を有効にするようにユーザーに促します。これは、ノーコードプッシュプライマーを使用して、SDK のカスタマイズなしで行うことができます。

ダイナミックなAPNゲートウェイ管理

ダイナミックなAppleプッシュ通知サービス(APN)ゲートウェイ管理は、適切なAPN環境を自動的に検出することで、iOSプッシュ通知の信頼性と効率性を高める。以前は、プッシュ通知用にAPN環境(開発環境または本番環境)を手動で選択する必要があった。これが原因で、ゲートウェイ設定の誤りや配信失敗、BadDeviceTokenエラーが発生することがあった。

ダイナミックなAPNゲートウェイ管理により、以下のことが可能になる:

  • 信頼性の向上:通知は常に正しいAPN環境に配信されるため、配信失敗が減る。
  • 簡易設定:APNゲートウェイの設定を手動で管理する必要はもうない。
  • エラー回復力:無効または欠落したゲートウェイ値は適切に処理され、サービスが中断されることはない。

前提条件

BrazeはiOS向けプッシュ通知において、ダイナミックなAPNゲートウェイ管理をサポートしている。以下のSDKバージョン要件を満たす必要がある:

仕組み

iOSアプリがBraze SWIFT SDKと連携する場合、利用可能な場合、デバイス関連データを含む情報をBrazeaps-environment SDK APIに送信する。このapns_gateway値は、アプリが開発用(dev)環境か本番用(prod)環境のAPNを使用しているかを示す。

Brazeはまた、各デバイスについてレポートされたゲートウェイ値を保存する。新しい有効なゲートウェイ値が受信された場合、Brazeは保存された値を自動的に更新する。

Brazeがプッシュ通知を送信するとき:

  • デバイスに有効なゲートウェイ値(dev または prod)が保存されている場合、Braze はそれを使用して正しい APN 環境を決定する。
  • ゲートウェイ値が保存されていない場合、Brazeはアプリ設定ページで設定されたAPN環境をデフォルトとして使用する。

よくある質問

なぜこの機能が導入されたのか?

ダイナミックなAPNゲートウェイ管理により、適切な環境が自動的に選択される。以前は、APNゲートウェイを手動で設定する必要があった。これによりエラーBadDeviceTokenやトークンの無効化、さらにはAPNのレート制限問題が発生する可能性があった。

この影響は配信パフォーマンスにどう影響するのか?

この機能は、プッシュトークンを常に正しいAPN環境にルーティングすることで配信率を向上させる。これにより、誤設定されたゲートウェイによる失敗を回避できる。

この機能を無効にできるか?

ダイナミックなAPNゲートウェイ管理はデフォルトで有効になっており、信頼性の向上を提供する。手動でのゲートウェイ選択が必要な具体的なユースケースがある場合は、Brazeサポートに連絡すること。

Androidテレビ用プッシュ通知について

Android TV プッシュ統合は、ネイティブ機能ではありませんが、Braze Android SDK と Firebase Cloud Messaging を利用して Android TV のプッシュトークンを登録することで使用可能になります。ただし、通知ペイロードを受信した後にそれを表示する UI を構築する必要があります。

前提条件

この機能を使用するには、次の手順を実行する必要があります。

プッシュ通知のセットアップ

Androidテレビのプッシュ通知を設定するには:

  1. アプリでカスタムビューを作成して、通知を表示します。
  2. カスタム通知ファクトリーを作成します。これにより、デフォルトの SDK 動作がオーバーライドされ、通知を手動で表示できるようになります。null を返すことで SDK の処理が妨げられ、通知を表示するためにカスタムコードが必要になります。これらの手順が完了したら、Android TV へのプッシュの送信を開始できます。

  3. (オプション)クリック分析を効果的に追跡するには、クリック分析 “トラッキングを設定します。これを行うには、Braze プッシュ通知の開封および受信インテントをリッスンするプッシュコールバックを作成します。

Androidテレビプッシュ通知のテスト

プッシュ実装が成功したかどうかをテストするには、通常 Android デバイスで行うように、Braze ダッシュボードから通知を送信します。

  • アプリケーションが閉じている場合:プッシュメッセージでは、画面にトースト通知が表示されます。
  • アプリケーションが開いている場合:独自にホストしている UI でメッセージを表示できます。Android Mobile SDK のアプリ内メッセージの UI スタイルに従うことをお勧めします。

ベストプラクティス

Braze を使用するマーケター s の場合、Android TV へのキャンペーンの起動は、携帯アプリs をAndroidするプッシュの起動と同じです。これらのデバイスのみをターゲットにするには、セグメンテーションで Android TV アプリを選択することをお勧めします。

FCM によって返される、配信およびクリックされた応答は、モバイル Android デバイスと同じ規則に従います。そのため、エラーがあれば、メッセージアクティビティログに表示されます。

前提条件

この機能を使う前に、Cordova Braze SDKを統合する必要がある。 SDKを統合すると、基本的なプッシュ通知機能はデフォルトでイネーブルメントされる。リッチプッシュ通知とプッシュストーリーを使用するには、それぞれ個別に設定する必要がある。iOSのプッシュ通知を利用するには、有効なプッシュ証明書もアップロードする必要がある。

プッシュディープリンクのイネーブルメント

デフォルトでは、Braze Cordova SDK はプッシュ通知からのディープリンクを自動的に処理しない。プッシュディープリンクのイネーブルメントを行うには、ディープリンクの設定ステップに従うこと。 これらの設定やその他のプッシュ設定オプションの詳細については、「オプションの設定」を参照のこと。

基本プッシュ通知を無効にする(iOSのみ)

iOS 用の Braze Cordova SDK を統合すると、基本的なプッシュ通知機能がデフォルトでイネーブルメントされる。iOSアプリでこの機能を無効にするには、設定config.xmlファイルに以下を追加する。詳細については、オプション設定を参照せよ。

1
2
3
4
<platform name="ios">
    <preference name="com.braze.ios_disable_automatic_push_registration" value="NO" />
    <preference name="com.braze.ios_disable_automatic_push_handling" value="NO" />
</platform>

前提条件

この機能を使う前に、Flutter Braze SDKを統合する必要がある。

プッシュ通知の設定

ステップ 1: 初期設定を完了する

ステップ1.1:プッシュ登録

Google の Firebase Cloud Messaging (FCM) API を使用してプッシュに登録します。詳しい手順については、「ネイティブ Android プッシュ通知統合ガイド」で以下の手順を参照してください。

  1. Firebase をプロジェクトに追加します
  2. Cloud Messaging を依存関係に追加します
  3. サービスアカウントを作成します
  4. JSON 認証情報を生成します
  5. JSON認証情報をBrazeにアップロードする

ステップ1.2:Google Sender IDを取得する

まず Firebase Console に移動し、プロジェクトを開いて、[設定] > [プロジェクト設定] を選択します。

設定」メニューが開封されたFirebaseプロジェクト。

[Cloud Messaging] 選択し、[Firebase Cloud Messaging API (V1)] の下にある [送信者 ID] をクリップボードにコピーします。

Firebaseプロジェクトの "Cloud Messaging "ページで、"Sender ID "がハイライトされている。

ステップ1.3:braze.xml を更新する

braze.xml ファイルに以下を追加する。FIREBASE_SENDER_ID を、以前にコピーした送信者 ID に置き前ます。

1
2
<bool translatable="false" name="com_braze_firebase_cloud_messaging_registration_enabled">true</bool>
<string translatable="false" name="com_braze_firebase_cloud_messaging_sender_id">FIREBASE_SENDER_ID</string>

ステップ1.1:APN証明書をアップロードする

Appleプッシュ通知サービス(APNs)証明書を生成し、Brazeダッシュボードにアップロードする。詳細な手順については、APN 証明書のアップロードを参照してください。

ステップ1.2:アプリにプッシュ通知サポートを追加する

ネイティブ iOS 統合ガイドの手順に従います。

ステップ2:プッシュ通知イベントをリッスンする(オプション)

Braze が検出して処理したプッシュ通知イベントをリッスンするには、subscribeToPushNotificationEvents() を呼び出し、実行する引数を渡します。

1
2
3
4
5
6
7
8
9
10
// Create stream subscription
StreamSubscription pushEventsStreamSubscription;

pushEventsStreamSubscription = braze.subscribeToPushNotificationEvents((BrazePushEvent pushEvent) {
  print("Push Notification event of type ${pushEvent.payloadType} seen. Title ${pushEvent.title}\n and deeplink ${pushEvent.url}");
  // Handle push notification events
});

// Cancel stream subscription
pushEventsStreamSubscription.cancel();
プッシュ通知イベントフィールド

プッシュ通知フィールドの完全なリストについては、以下の表を参照してください。

ステップ3:プッシュ通知の表示をテストする

ネイティブレイヤーでプッシュ通知を設定した後、統合をテストするには:

  1. Flutter アプリケーションでアクティブユーザーを設定します。これを行うには、braze.changeUser('your-user-id') を呼び出してプラグインを初期化します。
  2. [キャンペーン] に移動し、新しいプッシュ通知キャンペーンを作成します。テストしたいプラットフォームを選択します。
  3. テスト通知を作成し、[テスト] タブに移動します。テストユーザーと同じ user-id を追加し、[テストを送信] をクリックします。
  4. まもなくデバイスに通知が届くはずです。通知が表示されない場合は、通知センターで確認するか、設定を更新する必要が生じる場合があります。

前提条件

この機能を使用する前に、Android Braze SDKを統合する必要がある。

プッシュ通知の設定

Huawei 製の新しいスマートフォンには、プッシュ配信に使用されるサービス、Huawei Mobile Services (HMS) が、Google の Firebase Cloud Messaging (FCM) の代わりに搭載されています。

ステップ 1: Huawei 開発者アカウントに登録する

始める前に、Huawei 開発者アカウントへの登録と設定が必要です。Huawei アカウントで、[My Projects] > [Project Settings] > [App Information] に移動し、App IDApp secret を書き留めます。

ステップ 2:Braze ダッシュボードで新しい Huawei アプリを作成する

Braze ダッシュボードで、[設定] ナビゲーションの下にある [アプリ設定] に移動します。

[+ アプリ] をクリックし、名前 (My Huawei App など) を入力し、プラットフォームとして Android を選択します。

新しい Braze アプリを作成したら、プッシュ通知設定を見つけて、プッシュプロバイダーとして Huawei を選択します。次に、Huawei Client SecretHuawei App ID を指定します。

ステップ 3:Huawei メッセージング SDK をアプリに統合する

Huawei は、Huawei Messaging Service をアプリケーションに統合する Android 統合 codelab を提供しています。以下の手順に従って開始してください。

codelab が完了したら、カスタムの Huawei Message Service を作成してプッシュトークンを取得し、メッセージを Braze SDK に転送する必要があります。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class CustomPushService extends HmsMessageService {
  @Override
  public void onNewToken(String token) {
    super.onNewToken(token);
    Braze.getInstance(this.getApplicationContext()).setRegisteredPushToken(token);
  }

  @Override
  public void onMessageReceived(RemoteMessage remoteMessage) {
    super.onMessageReceived(remoteMessage);
    if (BrazeHuaweiPushHandler.handleHmsRemoteMessageData(this.getApplicationContext(), remoteMessage.getDataOfMap())) {
      // Braze has handled the Huawei push notification
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
class CustomPushService: HmsMessageService() {
  override fun onNewToken(token: String?) {
    super.onNewToken(token)
    Braze.getInstance(applicationContext).setRegisteredPushToken(token!!)
  }

  override fun onMessageReceived(hmsRemoteMessage: RemoteMessage?) {
    super.onMessageReceived(hmsRemoteMessage)
    if (BrazeHuaweiPushHandler.handleHmsRemoteMessageData(applicationContext, hmsRemoteMessage?.dataOfMap)) {
      // Braze has handled the Huawei push notification
    }
  }
}

カスタムプッシュサービスを追加した後、AndroidManifest.xml に以下を追加します。

1
2
3
4
5
6
7
<service
  android:name="package.of.your.CustomPushService"
  android:exported="false">
  <intent-filter>
    <action android:name="com.huawei.push.action.MESSAGING_EVENT" />
  </intent-filter>
</service>

ステップ 4: フォアグラウンド通知を処理する

デフォルトでは、アプリがフォアグラウンドにあるときにプッシュ通知が届くと、Huaweiは自動的にそれを表示する。プッシュ通知のペイロードをBrazeで処理させる場合(分析トラッキング、ディープリンク処理、カスタム処理のため)、メソッドHmsMessageService.onMessageReceived内で受信したプッシュデータをBrazeにルーティングする。

呼び出すとBrazeHuaweiPushHandler.handleHmsRemoteMessageData、BrazeはペイロードがBrazeプッシュ通知かどうかを判断し、該当する場合は通知を作成して表示する。詳細については、Android プッシュ通知のドキュメントにある「フォアグラウンド通知の処理」を参照せよ。

完全な例については、Braze Android SDKドキュメントのHuaweiハンドラーリファレンスを参照せよ。

ステップ 5: プッシュ通知をテストする(任意)

ここまでで、Braze ダッシュボードに新しい Huawei Android アプリを作成し、Huawei 開発者の認証情報を使用して設定し、Braze および Huawei SDK をアプリに統合しました。

次に、Braze で新しいプッシュキャンペーンをテストすることで、統合をテストします。

ステップ 5.1:新しいプッシュ通知キャンペーンを作成する

[キャンペーン] ページで、新しいキャンペーンを作成し、メッセージタイプとして [プッシュ通知] を選択します。

キャンペーンに名前を付けたら、プッシュプラットフォームとして [Android プッシュ通知] を選択します。

利用可能なプッシュ・プラットフォームを表示するキャンペーン作成コンポーザー。

次に、タイトルとメッセージを付けてプッシュキャンペーンを作成します。

ステップ 5.2:テストプッシュを送信する

[Test] タブで、changeUser(USER_ID_STRING) method を使ってアプリに設定したユーザーIDを入力し、[Send Test] をクリックしてテストプッシュを送信する。

キャンペーン作成コンポーザーのテストタブを見ると、ユーザーIDを入力し、「個人ユーザーを追加」フィールドに入力することで、自分自身にテストメッセージを送信できることがわかる。

この時点で、Braze から Huawei (HMS) デバイスにテストプッシュ通知が届くはずです。

ステップ 5.3:Huaweiセグメンテーションを設定する(任意)

Braze ダッシュボードの Huawei アプリは Android プッシュプラットフォーム上に構築されているため、すべての Android ユーザー (Firebase Cloud Messaging および Huawei Mobile Services) にプッシュを送信するか、キャンペーンオーディエンスを特定のアプリにセグメント化するかを柔軟に選択できます。

Huawei アプリのみにプッシュを送信するには、新しいセグメントを作成 して、[アプリ] セクション内で Huawei アプリを選択します。

もちろん、すべての Android プッシュプロバイダーに同じプッシュを送信する場合は、アプリを指定しないことを選択することで、現在のワークスペース内で設定されているすべての Android アプリに送信できます。

前提条件

この機能を使う前に、React Native Braze SDKを統合する必要がある。

プッシュ通知の設定

ステップ 1: 初期設定を完了する

前提条件

Expoでプッシュ通知を使う前に、Braze Expoプラグインを設定する必要があります。

ステップ1.1:app.json ファイルを更新する

次に、AndroidとiOS用の app.json ファイルを更新します:

  • Android:enableFirebaseCloudMessaging オプションを追加します。
  • iOS:enableBrazeIosPush オプションを追加します。

ステップ1.2:Google の送信者 ID を追加する

まず Firebase Console に移動し、プロジェクトを開いて、 設定 > プロジェクト設定 を選択します。

「設定」メニューが開いているFirebaseプロジェクト。

Cloud Messaging を選択し、Firebase Cloud Messaging API (V1) の下にある 送信者 ID をクリップボードにコピーします。

Firebaseプロジェクトの「Cloud Messaging」ページで「送信者ID」が強調表示されている。

次に、プロジェクトの app.json ファイルを開き、firebaseCloudMessagingSenderId プロパティをクリップボード内の送信者IDに設定します。以下に例を示します。

1
"firebaseCloudMessagingSenderId": "693679403398"

ステップ1.3:Google Services JSONへのパスを追加する

プロジェクトの app.json ファイルに、google-services.json ファイルへのパスを追加します。このファイルは、設定で enableFirebaseCloudMessaging: true を指定する場合に必要です。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
  "expo": {
    "android": {
      "googleServicesFile": "PATH_TO_GOOGLE_SERVICES"
    },
    "plugins": [
      [
        "@braze/expo-plugin",
        {
          "androidApiKey": "YOUR-ANDROID-API-KEY",
          "iosApiKey": "YOUR-IOS-API-KEY",
          "enableBrazeIosPush": true,
          "enableFirebaseCloudMessaging": true,
          "firebaseCloudMessagingSenderId": "YOUR-FCM-SENDER-ID",
          "androidHandlePushDeepLinksAutomatically": true
        }
      ],
    ]
  }
}

Expo Notifications などの追加のプッシュ通知ライブラリーに依存している場合は、ネイティブのセットアップ手順ではなく、これらの設定を使用する必要があることに注意してください。

Braze Expoプラグインを使用していない場合、またはこれらの設定をネイティブで構成したい場合は、ネイティブAndroidプッシュ統合ガイドを参照してプッシュ通知を登録してください。

Braze Expoプラグインを使用していない場合、またはこれらの設定をネイティブで構成したい場合は、ネイティブiOSプッシュ統合ガイドの以下のステップを参照してプッシュ登録を行ってください:

ステップ1.1:プッシュ通知の権限をリクエストする

アプリ起動時にプッシュ通知の権限をリクエストする予定がない場合は、AppDelegate内の requestAuthorizationWithOptions:completionHandler: 呼び出しを省略してください。その後、ステップ2に進んでください。それ以外の場合は、iOSネイティブ統合ガイドに従ってください。

ステップ1.2(オプション):プッシュキーを移行する

以前にプッシュキーの管理に expo-notifications を使用していた場合は、アプリケーションのルートフォルダーから expo fetch:ios:certs を実行してください。これにより、プッシュキー(.p8 ファイル)がダウンロードされ、その後 Braze ダッシュボードにアップロードできるようになります。

ステップ 2:プッシュ通知の許可をリクエストする

iOS および Android 13以降のユーザーにプッシュ通知の許可をリクエストするには、Braze.requestPushPermission() メソッド(v1.38.0以降で使用可能)を使用します。Android 12以前の場合、このメソッドは何も実行しません。

このメソッドは、SDK が iOS 上のユーザーにどの権限をリクエストするかを指定する必須パラメーターを受け取ります。これらのオプションは Android には影響しません。

1
2
3
4
5
6
7
8
const permissionOptions = {
  alert: true,
  sound: true,
  badge: true,
  provisional: false
};

Braze.requestPushPermission(permissionOptions);

ステップ 2.1:プッシュ通知をリッスンする(オプション)

さらに、Braze が受信プッシュ通知を検出して処理したイベントをサブスクライブすることもできます。リスナーキー Braze.Events.PUSH_NOTIFICATION_EVENT を使用します。

1
2
3
4
Braze.addListener(Braze.Events.PUSH_NOTIFICATION_EVENT, data => {
  console.log(`Push Notification event of type ${data.payload_type} seen. Title ${data.title}\n and deeplink ${data.url}`);
  console.log(JSON.stringify(data, undefined, 2));
});
プッシュ通知イベントフィールド

プッシュ通知フィールドの完全なリストについては、以下の表を参照してください。

ステップ3:ディープリンクを有効にする(オプション)

Reactコンポーネント内でプッシュ通知がクリックされた際にBrazeがディープリンクを処理できるようにするには、まずReact Native Linkingライブラリーで説明されているステップを実装するか、任意のソリューションで実装してください。次に、以下の追加ステップに従ってください。

ディープリンクの詳細については、FAQの記事を参照してください。

Braze Expoプラグインを使用している場合、app.jsonandroidHandlePushDeepLinksAutomaticallytrue に設定することで、プッシュ通知のディープリンクを自動的に処理できます。

代わりにディープリンクを手動で処理するには、ネイティブAndroidのドキュメントを参照してください:ディープリンクを追加する

ステップ 3.1:アプリ起動時にプッシュ通知のペイロードを保存する

メインアクティビティの onCreate() メソッドに populateInitialPushPayloadFromIntent を追加します。React Nativeが初期化される前にこれを呼び出して、初期のIntentデータをキャプチャする必要があります。以下に例を示します。

1
2
3
4
override fun onCreate(savedInstanceState: Bundle?) {
  BrazeReactUtils.populateInitialPushPayloadFromIntent(intent)
  super.onCreate(savedInstanceState)
}

ステップ 3.2:閉じている状態からのディープリンクを処理する

React Native Linkingが扱う基本シナリオに加えて、Braze.getInitialPushPayload メソッドを実装し、url の値を取得します。これにより、アプリが起動していない状態でプッシュ通知からアプリを開くディープリンクに対応できます。以下に例を示します。

1
2
3
4
5
6
7
8
// Handles deep links when an app is launched from a hard close via push click.
Braze.getInitialPushPayload(pushPayload => {
  if (pushPayload) {
    console.log('Braze.getInitialPushPayload is ' + pushPayload);
    showToast('Initial URL is ' + pushPayload.url);
    handleOpenUrl({ pushPayload.url });
  }
});

これには、カスタムURLスキームの登録と AppDelegate でのURLハンドラーの実装が含まれます。完全なセットアップ手順については、ネイティブiOSドキュメントのディープリンクの処理を参照してください。

ステップ 3.1:アプリ起動時にプッシュ通知のペイロードを保存する

iOS の場合は、AppDelegate の didFinishLaunchingWithOptions メソッドに populateInitialPayloadFromLaunchOptions を追加します。以下に例を示します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
  // ... Perform regular React Native setup

  BRZConfiguration *configuration = [[BRZConfiguration alloc] initWithApiKey:apiKey endpoint:endpoint];
  configuration.triggerMinimumTimeInterval = 1;
  configuration.logger.level = BRZLoggerLevelInfo;
  Braze *braze = [BrazeReactBridge initBraze:configuration];
  AppDelegate.braze = braze;

  [self registerForPushNotifications];
  [[BrazeReactUtils sharedInstance] populateInitialPayloadFromLaunchOptions:launchOptions];

  return [super application:application didFinishLaunchingWithOptions:launchOptions];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func application(
  _ application: UIApplication,
  didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
) -> Bool {
  // ... Perform regular React Native setup

  let configuration = Braze.Configuration(apiKey: apiKey, endpoint: endpoint)
  configuration.triggerMinimumTimeInterval = 1
  configuration.logger.level = .info
  let braze = BrazeReactBridge.initBraze(configuration)
  AppDelegate.braze = braze
  registerForPushNotifications()
  BrazeReactUtils.shared().populateInitialPayload(fromLaunchOptions: launchOptions)

  return super.application(application, didFinishLaunchingWithOptions: launchOptions)
}

ステップ 3.2:閉じている状態からのディープリンクを処理する

React Native Linkingが扱う基本シナリオに加えて、Braze.getInitialPushPayload メソッドを実装し、url の値を取得します。これにより、アプリが起動していない状態でプッシュ通知からアプリを開くディープリンクに対応できます。以下に例を示します。

1
2
3
4
5
6
7
8
// Handles deep links when an app is launched from a hard close via push click.
Braze.getInitialPushPayload(pushPayload => {
  if (pushPayload) {
    console.log('Braze.getInitialPushPayload is ' + pushPayload);
    showToast('Initial URL is ' + pushPayload.url);
    handleOpenUrl({ pushPayload.url });
  }
});

ステップ3.3:ユニバーサルリンクを有効にする(オプション)

ユニバーサルリンクのサポートを有効にするには、指定されたURLを開くかどうかを判断するBrazeデリゲートを実装し、それをBrazeインスタンスに登録します。

iOS ディレクトリ内に BrazeReactDelegate.swift ファイルを作成し、以下を追加します。YOUR_DOMAIN_HOST を実際のドメインに置き換えてください。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import Foundation
import BrazeKit
import UIKit

class BrazeReactDelegate: NSObject, BrazeDelegate {

  /// This delegate method determines whether to open a given URL.
  /// Reference the context to get additional details about the URL payload.
  func braze(_ braze: Braze, shouldOpenURL context: Braze.URLContext) -> Bool {
    if let host = context.url.host,
       host.caseInsensitiveCompare("YOUR_DOMAIN_HOST") == .orderedSame {
      // Sample custom handling of universal links
      let application = UIApplication.shared
      let userActivity = NSUserActivity(activityType: NSUserActivityTypeBrowsingWeb)
      userActivity.webpageURL = context.url
      // Routes to the `continueUserActivity` method, which should be handled in your AppDelegate.
      application.delegate?.application?(
        application,
        continue: userActivity,
        restorationHandler: { _ in }
      )
      return false
    }
    // Let Braze handle links otherwise
    return true
  }
}

次に、プロジェクトの AppDelegate.swift ファイルの didFinishLaunchingWithOptions 内で BrazeReactDelegate を作成し登録します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import BrazeKit

class AppDelegate: UIResponder, UIApplicationDelegate {
  
  static var braze: Braze?
  
  // Keep a strong reference to the BrazeDelegate so it is not deallocated.
  private var brazeDelegate: BrazeReactDelegate?
  
  func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
  ) -> Bool {
    // Other setup code (e.g., Braze initialization)
    
    brazeDelegate = BrazeReactDelegate()
    AppDelegate.braze?.delegate = brazeDelegate
    return true
  }
}

iOS ディレクトリ内に BrazeReactDelegate.h ファイルを作成し、以下のコードスニペットを追加します。

1
2
3
4
5
6
#import <Foundation/Foundation.h>
#import <BrazeKit/BrazeKit-Swift.h>

@interface BrazeReactDelegate: NSObject<BrazeDelegate>

@end

次に、BrazeReactDelegate.m ファイルを作成し、以下のコードスニペットを追加します。YOUR_DOMAIN_HOST を実際のドメインに置き換えてください。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#import "BrazeReactDelegate.h"
#import <UIKit/UIKit.h>

@implementation BrazeReactDelegate

/// This delegate method determines whether to open a given URL.
///
/// Reference the `BRZURLContext` object to get additional details about the URL payload.
- (BOOL)braze:(Braze *)braze shouldOpenURL:(BRZURLContext *)context {
  if ([[context.url.host lowercaseString] isEqualToString:@"YOUR_DOMAIN_HOST"]) {
    // Sample custom handling of universal links
    UIApplication *application = UIApplication.sharedApplication;
    NSUserActivity* userActivity = [[NSUserActivity alloc] initWithActivityType:NSUserActivityTypeBrowsingWeb];
    userActivity.webpageURL = context.url;
    // Routes to the `continueUserActivity` method, which should be handled in your `AppDelegate`.
    [application.delegate application:application
                 continueUserActivity:userActivity restorationHandler:^(NSArray<id<UIUserActivityRestoring>> * _Nullable restorableObjects) {}];
    return NO;
  }
  // Let Braze handle links otherwise
  return YES;
}

@end

次に、プロジェクトの AppDelegate.m ファイルの didFinishLaunchingWithOptions 内で BrazeReactDelegate を作成し登録します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#import "BrazeReactUtils.h"
#import "BrazeReactDelegate.h"

@interface AppDelegate ()

// Keep a strong reference to the BrazeDelegate to ensure it is not deallocated.
@property (nonatomic, strong) BrazeReactDelegate *brazeDelegate;

@end

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
  // Other setup code

  self.brazeDelegate = [[BrazeReactDelegate alloc] init];
  braze.delegate = self.brazeDelegate;
}

統合の例については、こちらのサンプルアプリを参照してください。

ステップ 4:フォアグラウンド通知を処理する

フォアグラウンド通知の処理は、プラットフォームや設定によって異なります。統合方法に合わせてアプローチを選択してください。

iOSでは、フォアグラウンド通知の処理はネイティブのSwift統合と同じです。UNUserNotificationCenterDelegate.userNotificationCenter(_:willPresent:withCompletionHandler:) の実装内で handleForegroundNotification(notification:) を呼び出します。

詳細な情報とコード例については、Swiftプッシュ通知のドキュメントにあるフォアグラウンド通知の処理を参照してください。

Androidの場合、フォアグラウンド通知の処理はネイティブのAndroid統合と同じです。FirebaseMessagingService.onMessageReceived メソッド内で BrazeFirebaseMessagingService.handleBrazeRemoteMessage を呼び出します。

詳細な情報とコード例については、Androidプッシュ通知のドキュメントにあるフォアグラウンド通知の処理を参照してください。

Expo管理ワークフローでは、ネイティブ通知ハンドラーを直接呼び出しません。代わりに、Expo Notifications API を使ってフォアグラウンド表示をコントロールし、Braze Expoプラグインがネイティブ処理を自動的に行います。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import * as Notifications from 'expo-notifications';
import Braze from '@braze/react-native-sdk';

// Control foreground presentation in Expo
Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldShowAlert: true,    // Show alert while in foreground
    shouldPlaySound: false,
    shouldSetBadge: false,
  }),
});

// React to Braze push events
const subscription = Braze.addListener('pushNotificationEvent', (event) => {
  console.log('Braze push event', {
    type: event.payload_type,   // "push_received" | "push_opened"
    title: event.title,
    url: event.url,
    is_silent: event.is_silent,
  });
  // Handle deep links, custom behavior, etc.
});

// Handle initial payload when app launches via push
Braze.getInitialPushPayload((payload) => {
  if (payload) {
    console.log('Initial push payload', payload);
  }
});

ベアワークフロー統合については、代わりにネイティブのiOSおよびAndroidのアプローチに従ってください。

ステップ 5:テストのプッシュ通知を送信する

この時点で、デバイスに通知を送信できるはずです。次のステップに従って、プッシュ統合をテストしてください。

  1. React Nativeアプリケーションで Braze.changeUserId('your-user-id') メソッドを呼び出して、アクティブユーザーを設定します。
  2. キャンペーンに移動し、新しいプッシュ通知キャンペーンを作成します。テストしたいプラットフォームを選択します。
  3. テスト通知を作成し、テストタブに移動します。テストユーザーと同じ user-id を追加し、テストを送信をクリックします。まもなくデバイスに通知が届くはずです。

Brazeのプッシュキャンペーンでは、自分のユーザーIDをテスト受信者として追加し、プッシュ通知をテストすることができます。

Expoプラグインを使う

Expoでプッシュ通知を設定した後、ネイティブのAndroidやiOSレイヤーでコードを書く必要なく、以下のプッシュ通知の動作を処理できます。

Androidプッシュを追加FMSに転送する

追加の Firebase Messaging Service(FMS)を使用する場合は、アプリケーションがBraze以外からプッシュを受信した場合に呼び出すフォールバックFMSを指定できます。以下に例を示します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "expo": {
    "plugins": [
      [
        "@braze/expo-plugin",
        {
          ...
          "androidFirebaseMessagingFallbackServiceEnabled": true,
          "androidFirebaseMessagingFallbackServiceClasspath": "com.company.OurFirebaseMessagingService"
        }
      ]
    ]
  }
}

Expo Application Servicesでアプリ拡張機能を使用する

Expo Application Services(EAS)を使用していて、enableBrazeIosRichPush または enableBrazeIosPushStories を有効にしている場合は、プロジェクト内の各アプリ拡張機能に対応するバンドル識別子を宣言する必要があります。EASでコード署名を管理するためにプロジェクトがどのように構成されているかによって、このステップにアプローチする方法は複数あります。

一つの方法は、Expoのアプリ拡張ドキュメントに従って、app.json ファイルで appExtensions 設定を使用することです。あるいは、Expoのローカル認証情報ドキュメントに従って、credentials.json ファイルで multitarget 設定を行うこともできます。

トラブルシューティング

以下は、Braze React Native SDKおよびExpoプラグインとのプッシュ通知統合における一般的なトラブルシューティングステップです。

プッシュ通知が機能しなくなった

Expoプラグイン経由のプッシュ通知が機能しなくなった場合:

  1. Braze SDKがまだセッションの追跡を行っているか確認してください。
  2. SDKが明示的または暗黙的な wipeData 呼び出しによって無効化されていないことを確認してください。
  3. Expoや関連ライブラリーの最近のアップグレードを確認してください。Brazeの設定と競合する可能性があります。
  4. 最近追加されたプロジェクトの依存関係を確認し、それらが既存のプッシュ通知デリゲートメソッドを手動で上書きしていないかチェックしてください。

デバイストークンがBrazeに登録されない

デバイストークンがBrazeに登録されない場合、まずプッシュ通知が機能しなくなったを確認してください。

問題が解決しない場合、別の依存関係がBrazeのプッシュ通知設定に干渉している可能性があります。それを削除するか、代わりに手動で Braze.registerPushToken を呼び出すことを試してください。

前提条件

この機能を使用する前に、Web Braze SDKを統合する必要がある。 Web SDK用のプッシュ通知設定する必要がある。iOSおよびiPadOSユーザーにプッシュ通知を送信できるのは、Safari v16.4以降を使用している場合に限られることに注意せよ。

モバイル向けSafariプッシュ通知の設定

ステップ 1: マニフェスト・ファイルを作成する

ウェブ・アプリケーション・マニフェストは、ユーザーのホーム画面にインストールされたときに、ウェブサイトがどのように表示されるかを制御するJSONファイルである。

例えば、App Switcherが使用する背景のテーマカラーやアイコン、ネイティブアプリのようにフルスクリーンでレンダリングするかどうか、アプリをランドスケープモードで開くかポートレートモードで開くかなどを設定できる。

ウェブサイトのルート・ディレクトリに、以下の必須フィールドを含む新しいmanifest.json ファイルを作成する。

1
2
3
4
5
6
7
8
9
{
  "name": "your app name",
  "short_name": "your app name",
  "display": "fullscreen",
  "icons": [{
    "src": "favicon.ico",
    "sizes": "128x128",
  }]
}

サポートされるフィールドの全リストはこちらで見ることができる。

ウェブサイトの<head> 要素に、マニフェストファイルがホストされている場所を指す次の<link> タグを追加する。

1
<link rel="manifest" href="/manifest.json" />

ステップ3:サービスワーカーを追加する

Web プッシュ統合ガイドで説明されているように、Web サイトには Braze service-worker ライブラリをインポートするサービスワーカーファイルが必要です。

ステップ4: ホーム画面に追加する

主要なブラウザ(Safari、Chrome、FireFox、Edgeなど)は、いずれも最新版でWeb プッシュ通知をサポートしている。iOSまたはiPadOSでプッシュ通知の権限を求めるには、ユーザーが「共有」>「ホーム画面に追加」を選択して、あなたのWeb サイトをホーム画面に追加する必要がある。ホーム画面に追加機能は、ユーザーがあなたの Web サイトをブックマークできるようにする。これにより、あなたのアイコンがユーザーの貴重なホーム画面スペースに追加されるのだ。

ウェブサイトをブックマークし、ホーム画面に保存するオプションを表示するiPhone

ステップ5:ネイティブのプッシュプロンプトを表示する

アプリがホーム画面に追加された後、ユーザーがアクション(ボタンをクリックするなど)を行った際にプッシュ通知の権限をリクエストできるようになる。これを行うには、requestPushPermission メソッドを使用するか、コードなしのプッシュプライマーのアプリ内メッセージを使用します。

通知を「許可する」か「許可しない」かを尋ねるプッシュ・プロンプトが表示される。

以下はその例です。

1
2
3
4
5
6
7
8
9
import { requestPushPermission } from "@braze/web-sdk";

button.onclick = function(){
    requestPushPermission(() => {
        console.log(`User accepted push prompt`);
    }, (temporary) => {
        console.log(`User ${temporary ? "temporarily dismissed" : "permanently denied"} push prompt`);
    });
};

次のステップ:

次に、自分自身にテスト・メッセージを送って、統合を検証する。統合が完了したら、プッシュオプトイン率を最適化するために、コードなしのプッシュプライマーメッセージを使用することができる。

前提条件

この機能を使用する前に、Unity Braze SDKを統合する必要がある。

プッシュ通知の設定

ステップ 1: プラットフォームを設定する

ステップ1.1:Firebaseを有効にする

開始するには、Firebase Unity の設定ドキュメントに従ってください。

ステップ1.2:Firebaseの認証情報を設定する

Firebase サーバーキーと送信者 ID を Braze ダッシュボードに入力する必要があります。これを行うには、Firebase Developers Consoleにログインし、Firebase プロジェクトを選択します。次に、[設定] で「クラウドメッセージング」を選択し、サーバーキーと送信者 ID をコピーします。

Braze のアプリ設定ページの [設定の管理] で Android アプリを選択します。次に、[Firebase Cloud Messaging サーバーキー] フィールドに「Firebase サーバーキー」を入力し、「Firebase Cloud メッセージング送信者」ID フィールドに「Firebase 送信者 ID」を入力します。

ステップ1.1:統合方法を検証する

Braze は、iOS プッシュ統合を自動化するための Unity ネイティブソリューションを提供します。代わりに手動で統合の設定と管理を行いたい場合は、Swiftを参照のこと:プッシュ通知.

それ以外の場合は、次の手順に進みます。

ステップ1.1:ADM を有効にする

  1. Amazon Apps& Games Developer Portalでまだアカウントを作成していない場合は、アカウントを作成する。
  2. OAuth 認証情報 (クライアント ID とクライアントシークレット) と ADM API キーを取得します。
  3. [Unity Braze 設定]ウィンドウで [自動 ADM 登録が有効] を有効にします。
    • または、res/values/braze.xml ファイルに次の行を追加して、ADM 登録を有効にすることもできます。
1
  <bool name="com_braze_push_adm_messaging_registration_enabled">true</bool>

ステップ 2:プッシュ通知を構成する

ステップ 2.1: プッシュ設定を行う

Braze SDK は、Firebase Cloud メッセージングサーバーへのプッシュ登録を自動的に処理して、デバイスがプッシュ通知を受信できるようにすることができます。Unityで、Automate Unity Android Integrationを有効にし、以下のプッシュ通知の設定を行う。

ステップ 2.1: APN トークンをアップロードする

Brazeを使ってiOSプッシュ通知を送信する前に、Appleの開発者向けドキュメントに記載されているように、.p8 プッシュ通知ファイルをアップロードする必要がある:

  1. Apple 開発者アカウントで、以下にアクセスする。 証明書、識別子& プロファイル.
  2. [キー] で [すべて] を選択し、右上の追加ボタン (+) をクリックします。
  3. [キーの説明]で、署名キーの一意の名前を入力します。
  4. [キーサービス] で [Apple プッシュ通知サービス (APNs)] チェックボックスをオンにし、[続行] をクリックします。[確認] をクリックします。
  5. キー ID をメモしておきます。[ダウンロード] をクリックして、キーを生成してダウンロードします。ダウンロードしたファイルは、何度もダウンロードできませんので、安全な場所に保存してください。
  6. Braze で、[設定] > [アプリ設定] に移動し、[Apple プッシュ通知証明書] で .p8 ファイルをアップロードします。開発用または実稼働用のプッシュ証明書のいずれかをアップロードできます。アプリが App Store で公開された後にプッシュ通知をテストするには、アプリの開発バージョン用に別のワークスペースを設定することをお勧めします。
  7. プロンプトが表示されたら、アプリのバンドルIDキーIDチームIDを入力する。また、アプリの開発環境と本番環境のどちらに通知を送るかを指定する必要があるが、これはアプリのプロビジョニング・プロファイルによって定義される。
  8. 完了したら、[保存] を選択します。

ステップ 2.2:自動プッシュをイネーブルメントにする

Unity エディターで [Braze] > [Braze 構成] の順に移動して、[Braze 構成設定] を開きます。

[プッシュと Braze を統合する] をチェックして、プッシュ通知用に自動的にユーザーを登録し、プッシュトークンを Braze に渡し、プッシュ開封の分析を追跡し、デフォルトのプッシュ通知処理を利用します。

ステップ 2.3:バックグラウンドプッシュを有効にする(オプション)

プッシュ通知で background mode を有効にする場合は、[バックグラウンドプッシュを有効にする] をオンにします。これにより、プッシュ通知が到着したときにシステムがアプリケーションを suspended 状態から復帰させ、アプリケーションがプッシュ通知に応答してコンテンツをダウンロードできるようになります。アンインストールの追跡機能を使用するには、このオプションをオンにする必要があります。

UnityエディターはBrazeの設定オプションを表示する。このエディターでは、「Unity iOS 統合の自動化」、「プッシュと Braze の統合」、および「バックグラウンドプッシュの有効化」が有効になっています。

ステップ 2.4:自動登録を無効にする(オプション)

まだプッシュ通知をオプトインしていないユーザーは、アプリケーションを開くと自動的にプッシュ通知が許可されます。この機能を無効にし、手動でユーザーをプッシュ登録するには、[Disable Automatic Push Registration (自動プッシュ登録を無効にする)] をチェックします。

  • IOS 12 以降で [暫定承認を無効にする] がオンになっていない場合、ユーザーはサイレントプッシュを受信することを暫定的に (サイレントに) 承認されます。チェックした場合、ユーザーにネイティブのプッシュプロンプトが表示される。
  • 実行時にプロンプトが表示されるタイミングを正確に設定する必要がある場合は、Braze 構成エディターから自動登録を無効にし、代わりに AppboyBinding.PromptUserForPushPermissions() を使用します。

UnityエディターはBrazeの設定オプションを表示する。このエディターでは、「Unity iOS 統合の自動化」、「プッシュと Braze の統合」、および「プッシュの自動登録の有効化」が有効になっています。

ステップ 2.1: AndroidManifest.xml を更新する

アプリにAndroidManifest.xml がない場合は、以下をテンプレートとして使用できます。それ以外の場合、すでにAndroidManifest.xml がある場合は、次のいずれかの欠落セクションが既存のAndroidManifest.xml に追加されていることを確認します。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="REPLACE_WITH_YOUR_PACKAGE_NAME">

  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  <uses-permission android:name="android.permission.INTERNET" />
  <permission
    android:name="REPLACE_WITH_YOUR_PACKAGE_NAME.permission.RECEIVE_ADM_MESSAGE"
    android:protectionLevel="signature" />
  <uses-permission android:name="REPLACE_WITH_YOUR_PACKAGE_NAME.permission.RECEIVE_ADM_MESSAGE" />
  <uses-permission android:name="com.amazon.device.messaging.permission.RECEIVE" />

  <application android:icon="@drawable/app_icon" 
               android:label="@string/app_name">

    <!-- Calls the necessary Braze methods to ensure that analytics are collected and that push notifications are properly forwarded to the Unity application. -->
    <activity android:name="com.braze.unity.BrazeUnityPlayerActivity" 
      android:label="@string/app_name" 
      android:configChanges="fontScale|keyboard|keyboardHidden|locale|mnc|mcc|navigation|orientation|screenLayout|screenSize|smallestScreenSize|uiMode|touchscreen" 
      android:screenOrientation="sensor">
      <meta-data android:name="android.app.lib_name" android:value="unity" />
      <meta-data android:name="unityplayer.ForwardNativeEventsToDalvik" android:value="true" />
      <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
      </intent-filter>
    </activity>

    <receiver android:name="com.braze.push.BrazeAmazonDeviceMessagingReceiver" android:permission="com.amazon.device.messaging.permission.SEND">
      <intent-filter>
          <action android:name="com.amazon.device.messaging.intent.RECEIVE" />
          <action android:name="com.amazon.device.messaging.intent.REGISTRATION" />
          <category android:name="REPLACE_WITH_YOUR_PACKAGE_NAME" />
      </intent-filter>
    </receiver>
  </application>
</manifest>

ステップ 2.2:ADM API キーを保存する

まず、アプリ用のADM API Keyを生成し、そのキーをapi_key.txt という名前のファイルに保存して、プロジェクトの Assets/ディレクトリに追加する。

次に、mainTemplate.gradle

1
2
3
4
5
6
7
task copyAmazon(type: Copy) {
    def unityProjectPath = $/file:///**DIR_UNITYPROJECT**/$.replace("\\", "/")
    from unityProjectPath + '/Assets/api_key.txt'
    into new File(projectDir, 'src/main/assets')
}

preBuild.dependsOn(copyAmazon)

ステップ 2.3:ADMジャーを追加する

必要なADM Jar ファイルは、Unity JAR ドキュメント に従ってプロジェクト内の任意の場所に配置できます。

ステップ 2.4:クライアントシークレットとクライアント ID を Braze ダッシュボードに追加する

最後に、ステップ 1 で取得したクライアントシークレットとクライアント ID を Braze ダッシュボードの [設定の管理] ページに追加する必要があります。

ステップ 3:プッシュリスナーを設定する

ステップ 3.1:プッシュ受信リスナーをイネーブルメントする

プッシュ受信リスナーは、ユーザーがプッシュ通知を受信したときに起動される。Unity にプッシュペイロードを送信するには、ゲームオブジェクトの名前を設定し、[プッシュ受信リスナーの設定] の下にある受信リスナーのコールバックメソッドをプッシュします。

ステップ 3.2:プッシュ開封リスナーをイネーブルメントする

ユーザーがプッシュ通知をクリックしてアプリを起動すると、プッシュ開封済みリスナーが起動します。Unity にプッシュペイロードを送信するには、ゲームオブジェクトの名前を設定し、[プッシュ開封済みリスナーを設定する] の下にある開封済みリスナーのコールバックメソッドをプッシュします。

ステップ3.3:プッシュ削除リスナーをイネーブルメントする

プッシュ削除リスナーは、ユーザーがプッシュ通知をスワイプして削除したり、無視したときに起動されます。Unity にプッシュペイロードを送信するには、ゲームオブジェクトの名前を設定し、[プッシュ削除済みリスナーを設定する] の下にある削除済みリスナーのコールバックメソッドをプッシュします。

プッシュ・リスナーの例

次の例では、コールバックメソッド名 PushNotificationReceivedCallbackPushNotificationOpenedCallback、および PushNotificationDeletedCallback をそれぞれ使用して、BrazeCallback ゲームオブジェクトを実装します。

この実装例の図は、前のセクションで述べた Braze の構成オプションと、C# のコードスニペットを示しています。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class MainMenu : MonoBehaviour {
  void PushNotificationReceivedCallback(string message) {
#if UNITY_ANDROID
    Debug.Log("PushNotificationReceivedCallback message: " + message);
    PushNotification pushNotification = new PushNotification(message);
    Debug.Log("Push Notification received: " + pushNotification);   
#elif UNITY_IOS
    ApplePushNotification pushNotification = new ApplePushNotification(message);
    Debug.Log("Push received Notification event: " + pushNotification);   
#endif  
  }

  void PushNotificationOpenedCallback(string message) {
#if UNITY_ANDROID
    Debug.Log("PushNotificationOpenedCallback message: " + message);
    PushNotification pushNotification = new PushNotification(message);
    Debug.Log("Push Notification opened: " + pushNotification);  
#elif UNITY_IOS
    ApplePushNotification pushNotification = new ApplePushNotification(message);
    Debug.Log("Push opened Notification event: " + pushNotification);   
#endif  
  }

  void PushNotificationDeletedCallback(string message) {
#if UNITY_ANDROID
    Debug.Log("PushNotificationDeletedCallback message: " + message);
    PushNotification pushNotification = new PushNotification(message);
    Debug.Log("Push Notification dismissed: " + pushNotification);  
#endif
  }
}

ステップ 3.1:プッシュ受信リスナーをイネーブルメントする

プッシュ受信リスナーは、ユーザーがアプリケーションをアクティブに使用しているとき(アプリがフォアグラウンドになっているときなど)にプッシュ通知を受信すると起動する。Brazeコンフィギュレーションエディターでプッシュ受信リスナーを設定する。ゲームオブジェクトのリスナーを実行時に設定する必要がある場合は、AppboyBinding.ConfigureListener() を使用し、BrazeUnityMessageType.PUSH_RECEIVED を指定します。

UnityエディターはBrazeの設定オプションを表示する。このエディターでは、「プッシュ受信リスナーの設定」オプションが展開され、「ゲームオブジェクト名」(AppBoyCallback) と「コールバックメソッド名」(PushNotificationReceivedCallback) が指定されます。

ステップ 3.2:プッシュ開封リスナーをイネーブルメントする

ユーザーがプッシュ通知をクリックしてアプリを起動すると、プッシュ開封済みリスナーが起動します。Unity にプッシュペイロードを送信するには、ゲームオブジェクトの名前を設定し、[プッシュ開封済みリスナーを設定する] オプションの下にある開封済みリスナーのコールバックメソッドをプッシュします。

UnityエディターはBrazeの設定オプションを表示する。このエディターでは、「プッシュ受信リスナーの設定」オプションが展開され、「ゲームオブジェクト名」(AppBoyCallback) と「コールバックメソッド名」(PushNotificationOpenedCallback) が指定されます。

ゲームオブジェクトのリスナーを実行時に設定する必要がある場合は、AppboyBinding.ConfigureListener() を使用し、BrazeUnityMessageType.PUSH_OPENED を指定します。

プッシュ・リスナーの例

次の例では、コールバックメソッド名 PushNotificationReceivedCallback、および PushNotificationOpenedCallback をそれぞれ使用して、AppboyCallback ゲームオブジェクトを実装します。

この実装例の図は、前のセクションで述べた Braze の構成オプションと、C# のコードスニペットを示しています。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class MainMenu : MonoBehaviour {
  void PushNotificationReceivedCallback(string message) {
#if UNITY_ANDROID
    Debug.Log("PushNotificationReceivedCallback message: " + message);
    PushNotification pushNotification = new PushNotification(message);
    Debug.Log("Push Notification received: " + pushNotification);   
#elif UNITY_IOS
    ApplePushNotification pushNotification = new ApplePushNotification(message);
    Debug.Log("Push received Notification event: " + pushNotification);   
#endif  
  }

  void PushNotificationOpenedCallback(string message) {
#if UNITY_ANDROID
    Debug.Log("PushNotificationOpenedCallback message: " + message);
    PushNotification pushNotification = new PushNotification(message);
    Debug.Log("Push Notification opened: " + pushNotification);  
#elif UNITY_IOS
    ApplePushNotification pushNotification = new ApplePushNotification(message);
    Debug.Log("Push opened Notification event: " + pushNotification);   
#endif  
  }
}

前のステップで AndroidManifest.xml 、プッシュ・リスナーが自動的に設定された。だから、これ以上の設定は必要ない。

1
2
<action android:name="com.amazon.device.messaging.intent.RECEIVE" />
<action android:name="com.amazon.device.messaging.intent.REGISTRATION" />

オプション構成

アプリ内リソースへのディープリンク

Braze はデフォルトで標準的なディープリンク (Web サイトのURL、Android の URI など) を処理できますが、カスタムディープリンクを作成するには、追加のマニフェスト設定が必要です。

設定ガイダンスについては、[アプリ内リソースへのディープリンク] を参照してください。

Braze プッシュ通知アイコンの追加

プロジェクトにプッシュアイコンを追加するには、アイコンイメージファイルを含むAndroid アーカイブ(AAR) プラグインまたはAndroid ライブラリを作成します。手順と情報については、Unity のドキュメントを参照してください。AndroidライブラリプロジェクトとAndroidアーカイブプラグイン

プッシュトークンコールバック

OS から Braze デバイストークンのコピーを受け取るには、AppboyBinding.SetPushTokenReceivedFromSystemDelegate() を使用してデリゲートを設定します。

現時点では、ADMのオプション設定はない。

前提条件

この機能を使う前に、.NET MAUI Braze SDKを統合する必要がある。

プッシュ通知の設定

.NET MAUI(旧称Xamarin)向けにプッシュ通知を統合するには、ネイティブAndroidプッシュ通知のステップを完了する必要がある。以下の手順はあくまで概要である。完全なチュートリアルについては、ネイティブ・プッシュ通知ガイドを参照のこと。

ステップ1:プロジェクトを更新する

  1. AndroidプロジェクトにFirebaseを追加する。
  2. Android プロジェクトの build.gradle に Cloud Messaging ライブラリを追加します。
    1
    
      implementation "google.firebase:firebase-messaging:+"
    

ステップ2:JSON認証情報を作成する

  1. Google Cloud で、Firebase Cloud Messaging API を有効にします。
  2. [サービスアカウント] > [プロジェクト] > [サービスアカウントの作成] の順に選択し、サービスアカウント名、ID、説明を入力します。完了したら、Createを選択して続ける
  3. [ロール] フィールドで、ロールのリストから [Firebase Cloud Messaging API 管理者] を見つけて選択します。
  4. [サービスアカウント] でプロジェクトを選択し、[アクション] > [キーの管理] > [キーの追加] > [新しいキーの作成] の順に選択します。[JSON] を選択し、[作成] を選択します。

ステップ3:JSON認証情報をアップロードする

  1. Braze で、[設定] > [アプリの設定] を選択します。Android アプリの [プッシュ通知設定] で [Firebase] を選択し、[JSON ファイルのアップロード] を選択して、先ほど生成した認証情報をアップロードします。完了したら、[保存] を選択します。
  2. Firebase Consoleにアクセスして、FCMトークンの自動登録を有効にする。プロジェクトを開き、[設定] > [プロジェクト設定] の順に選択します。[Cloud Messaging] を選択し、[Firebase Cloud Messaging API (V1)] で [送信者 ID] フィールドの数字をコピーします。
  3. Android Studio プロジェクトで、以下を braze.xml に追加します。
1
2
  <bool translatable="false" name="com_braze_firebase_cloud_messaging_registration_enabled">true</bool>
  <string translatable="false" name="com_braze_firebase_cloud_messaging_sender_id">FIREBASE_SENDER_ID</string>

ステップ 1: 初期設定を完了する

プッシュを使ったアプリケーションの設定や、認証情報をサーバーに保存する方法については、SWIFT の統合に関する説明を参照してください。詳細はiOS MAUIサンプル・アプリケーションを参照のこと。

ステップ2:プッシュ通知の許可をリクエストする

当社の.NET MAUI SDKは、自動プッシュ設定をサポートするようになった。Brazeインスタンス構成に以下のコードを追加して、プッシュ自動化とパーミッションを設定する:

1
2
configuration.Push.Automation = new BRZConfigurationPushAutomation(true);
configuration.Push.Automation.RequestAuthorizationAtLaunch = false;

詳細はiOS MAUIサンプル・アプリケーションを参照のこと。詳細については、Xamarin.iOS の拡張ユーザー通知に関する Xamarin ドキュメントを参照してください。

New Stuff!