コンテンツにスキップ

プッシュ通知

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

前提条件

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

プッシュプロトコル

Webプッシュ通知は、W3Cプッシュ標準を使用して実装されており、ほとんどの主要なブラウザーがサポートしています。特定のプッシュプロトコル標準とブラウザーのサポートの詳細については、AppleMozilla、およびMicrosoftのリソースを参照してください。

プッシュ通知の設定

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

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

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

ブラウザーがプッシュ通知を受信できるようユーザーにプッシュ権限を即座にリクエストするには、braze.requestPushPermission()を呼び出します。ユーザーのブラウザーでプッシュがサポートされているかを先にテストするには、braze.isPushSupported()を呼び出します。

プッシュ権限をリクエストする前に、独自のプッシュ関連UIを表示するために、ユーザーにソフトプッシュプロンプトを送信することもできます。

ステップ3: skipWaitingを無効にする(任意)

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

ユーザーの購読解除

ユーザーを購読解除するには、braze.unregisterPush()を呼び出します。

代替ドメイン

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

ユースケース

W3Cプッシュ標準に記載されているすべての条件を満たせない場合、この方法を使用してWebサイトにプッシュプロンプトダイアログを追加できます。これは、httpのWebサイトやブラウザー拡張機能のポップアップからユーザーにオプトインさせたい場合で、プッシュプロンプトの表示が妨げられている場合に役立ちます。

考慮事項

Web上の多くの回避策と同様に、ブラウザーは絶えず進化しており、この方法は将来的に使用できなくなる可能性があることに注意してください。続行する前に、以下を確認してください。

  • 別のセキュアなドメイン(https://)を所有しており、そのドメインにService Workerを登録する権限があること。
  • ユーザーがWebサイトにログインしていること。これにより、プッシュトークンが正しいプロファイルに紐付けられます。

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

以下の例をわかりやすくするために、http://insecure.comhttps://secure.comを2つのドメインとして使用し、http://insecure.comの訪問者にプッシュ登録をしてもらうことを目標とします。この例は、ブラウザー拡張機能のポップアップページのchrome-extension://スキームにも適用できます。

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

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

http://insecure.com

<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から開始されるこのワークフローでユーザーがオプトインできるようになったので、ユーザーがすでにオプトイン済みかどうかに基づいてサイトを変更したい場合があります。すでに登録済みのユーザーにプッシュ登録を求める意味はありません。

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

insecure.com

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

<!-- 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-Allowed HTTPヘッダーを使用する方法があります。サーバーがサービスワーカーのレスポンスにService-Worker-Allowed: /を返すよう設定することで、ブラウザーにスコープを拡大するよう指示し、別のディレクトリから使用できるようになります。

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

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

サイトセキュリティ

HTTPSは必須ですか?

はい。Web標準では、プッシュ通知の権限をリクエストするドメインはセキュアである必要があります。

サイトが「セキュア」と見なされるのはいつですか?

サイトは、以下のセキュアオリジンパターンのいずれかに一致する場合にセキュアと見なされます。Braze Webプッシュ通知はこのオープンスタンダードに基づいて構築されているため、中間者攻撃が防止されます。

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

セキュアなサイトが利用できない場合はどうすればよいですか?

業界のベストプラクティスとしてサイト全体をセキュアにすることが推奨されますが、サイトドメインをセキュアにできない場合は、セキュアモーダルを使用して要件を回避できます。詳細は代替プッシュドメインの使用に関するガイドを参照するか、動作デモをご覧ください。

前提条件

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

ビルトイン機能

以下の機能はBraze Android SDKにビルトインされています。その他のプッシュ通知機能を使用するには、アプリにプッシュ通知を設定する必要があります。

機能 説明
Push Stories Android Push StoriesはデフォルトでBraze Android SDKにビルトインされています。詳細については、Push Storiesを参照してください。
プッシュプライマー プッシュプライマーキャンペーンは、ユーザーにデバイスでアプリのプッシュ通知を有効にするよう促します。これは、ノーコードプッシュプライマーを使用して、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を追加する

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

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

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

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

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

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:サービスアカウントを作成する

次に、BrazeがFCMトークンを登録する際に認可済みAPI呼び出しを行えるよう、新しいサービスアカウントを作成します。Google CloudでService Accountsに移動し、プロジェクトを選択します。Service AccountsページでCreate Service Accountを選択します。

「Create Service Account」がハイライトされたプロジェクトのサービスアカウントホームページ

サービスアカウント名、ID、説明を入力し、Create and continueを選択します。

Roleフィールドで、ロール一覧からFirebase Cloud Messaging API Adminを検索して選択します。より制限されたアクセスにするには、cloudmessaging.messages.create権限を持つカスタムロールを作成し、一覧からそのロールを選択します。完了したら、Doneを選択します。

「Firebase Cloud Messaging API Admin」がロールとして選択された「Grant this service account access to project」フォーム

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

次に、FCMサービスアカウントのJSON認証情報を生成します。Google Cloud IAM & AdminでService Accountsに移動し、プロジェクトを選択します。先ほど作成したFCMサービスアカウントを見つけ、 Actions > Manage Keysを選択します。

「Actions」メニューが開いた状態のプロジェクトのサービスアカウントホームページ

Add Key > Create new keyを選択します。

「Add Key」メニューが開いた状態の選択されたサービスアカウント

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

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

「JSON」が選択された秘密キーの作成フォーム

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

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

Brazeで「設定」メニューが開き、「アプリ設定」がハイライトされた状態

AndroidアプリのPush Notification Settingsで、Firebaseを選択し、Upload JSON Fileを選択して先ほど生成した認証情報をアップロードします。完了したら、Saveを選択します。

「Firebase」がプッシュプロバイダーとして選択された「Push Notification Settings」フォーム

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

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

まず、Firebaseコンソールに移動し、プロジェクトを開き、 Settings > Project settingsを選択します。

「Settings」メニューが開いた状態のFirebaseプロジェクト

Cloud Messagingを選択し、Firebase Cloud Messaging API (V1)の下にあるSender IDフィールドの番号をコピーします。

「Sender ID」がハイライトされたFirebaseプロジェクトの「Cloud Messaging」ページ

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

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

<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は以下のようになります。

<?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に以下の行を追加します。

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

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

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);
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)

複数のFirebaseプロジェクトを使用する

アプリが複数のFirebaseプロジェクトを使用している場合は、以下の手順に従ってください。

  1. アプリのgoogle-services.jsonから初期化されるデフォルトのFirebaseプロジェクトでBrazeプッシュを維持します。
  2. カスタムFirebaseメッセージングサービスを使用する場合は、カスタムFirebaseメッセージングサービスでインストールIDを登録するを完了します。
  3. アプリが別の方法でプッシュトークンを取得する場合は、前述のヒントに示すように手動でregisteredPushTokenを設定します。

バージョンの詳細については、SDKの変更履歴を参照してください。

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

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

通知の表示

ステップ1:Braze Firebase Messaging Serviceを登録する

新規、既存、またはBraze以外のFirebase Messaging Serviceを作成できます。特定のニーズに最も適したものを選択してください。

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

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

カスタムFirebaseメッセージングサービスでインストールIDを登録する

firebase-messaging v25.1.0以降を使用している場合、Firebase登録にはFirebaseインストールIDが使用されます。カスタムFirebaseメッセージングサービスで、onRegisteredをオーバーライドし、registeredPushTokenを設定します。

public class MyFirebaseMessagingService extends FirebaseMessagingService {
  @Override
  public void onRegistered(String installationId) {
    super.onRegistered(installationId);
    Braze.getInstance(this).setRegisteredPushToken(installationId);
  }

  @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.
    }
  }
}
class MyFirebaseMessagingService : FirebaseMessagingService() {
  override fun onRegistered(installationId: String) {
    super.onRegistered(installationId)
    Braze.getInstance(this).registeredPushToken = installationId
  }

  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 Messaging Serviceがある場合は、アプリケーションがBraze以外のプッシュを受信したときに呼び出されるフォールバックFirebase Messaging Serviceを指定することもできます。

braze.xmlで以下を指定します。

<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>

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

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

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

Androidの通知アイコンに関する一般的な情報については、通知の概要を参照してください。

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

通知の小さいアイコンアセットを正しく表示するには:

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

以下に示す大きいアイコンと小さいアイコンは、適切にデザインされたアイコンの例です。

大きいアイコンの下隅に表示される小さいアイコンと、メッセージの横に表示されている例

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

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

Brazeでは、braze.xmlでドローアブルリソースを指定して通知アイコンを設定できます。

<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がシステム通知に使用するグレーと同じです。

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

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

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

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

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

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

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

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

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

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

仕組み

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

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
        }
    }
}
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というアクティビティをバックスタックアクティビティとして設定するには、以下のようにします。

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

braze.xmlでの同等の設定については、以下を参照してください。クラス名はClass.forName()で返される名前と同じである必要があります。

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

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

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

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

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

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

<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(オプション)
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通知シェードに表示された会話セクション。異なる連絡先からの3つのグループ化された会話通知が表示されています。

人と会話イニシアチブは、スマートフォンのシステムサーフェスにおいて人と会話を優先的に表示することを目的とした、複数年にわたるAndroidイニシアチブです。この優先順位は、他の人とのコミュニケーションやインタラクションが、すべてのデモグラフィックにわたるAndroidユーザーの大多数にとって、依然として最も価値があり重要な機能領域であるという事実に基づいています。

使用要件

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

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

FCMクォータ超過エラー

Firebase Cloud Messaging(FCM)の制限を超過すると、Googleは「quota exceeded」エラーを返します。FCMのデフォルト制限は、1分あたり600,000リクエストです。Brazeは、Googleが推奨するベストプラクティスに従って送信をリトライします。ただし、これらのエラーが大量に発生すると、送信時間が数分長くなる可能性があります。潜在的な影響を軽減するために、Brazeはレート制限を超過していることを通知するアラートと、エラーを防ぐために実行できる手順を送信します。

現在の制限を確認するには、Google Cloud Console > APIs & Services > Firebase Cloud Messaging API > Quotas & System Limitsに移動するか、FCM APIクォータページにアクセスしてください。

ベストプラクティス

これらのエラー量を低く保つために、以下のベストプラクティスをお勧めします。

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

FCMにレート制限の引き上げをリクエストするには、Firebaseサポートに直接お問い合わせいただくか、以下の手順を実行してください。

  1. FCM APIクォータページに移動します。
  2. Send requests per minuteのクォータを見つけます。
  3. Edit Quotaを選択します。
  4. 新しい値を入力してリクエストを送信します。

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

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

レート制限

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

プッシュ通知の設定

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

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

  1. Apple開発者アカウントで、Certificates, Identifiers & Profilesにアクセスします。
  2. KeysAllを選択し、ページ上部の追加ボタン(+)をクリックします。
  3. Key Descriptionで、署名キーの一意の名前を入力します。
  4. Key ServicesApple Push Notification service (APNs)チェックボックスをオンにし、Continueをクリックします。Confirmをクリックします。
  5. キーIDをメモしておきます。Downloadをクリックして、キーを生成してダウンロードします。ダウンロードしたファイルは安全な場所に保存してください。このファイルは一度しかダウンロードできません。
  6. Brazeで、設定 > アプリ設定に移動し、Apple Push Certificate.p8ファイルをアップロードします。開発用または本番用のプッシュ証明書のいずれかをアップロードできます。アプリがApp Storeで公開された後にプッシュ通知をテストするには、アプリの開発バージョン用に別のワークスペースを設定することをお勧めします。
  7. プロンプトが表示されたら、アプリのバンドルIDキーIDチームIDを入力します。また、アプリの開発環境と本番環境のどちらに通知を送信するかを指定する必要があります。これはプロビジョニングプロファイルによって定義されます。
  8. 完了したら、保存を選択します。

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

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

Xcodeプロジェクトの「Signing & Capabilities」セクション

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

Swift SDKを使用して、Brazeから受信したリモート通知の処理を自動化できます。これはプッシュ通知を処理する最もシンプルな方法であり、推奨される処理方法です。

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

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

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

これにより、SDKは以下を行います。

  • システムにプッシュ通知用のアプリケーションを登録します。
  • 初期化時にプッシュ通知の認可/許可をリクエストします。
  • プッシュ通知関連のシステムデリゲートメソッドの実装をダイナミックに提供します。

ステップ3.2:個別の構成をオーバーライドする(オプション)

より詳細なコントロールのために、各オートメーションステップを個別に有効または無効にできます。

// Enable all automations and disable the automatic notification authorization request at launch.
configuration.push.automation = true
configuration.push.automation.requestAuthorizationAtLaunch = false
// 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:APNsにプッシュ通知を登録する

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

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

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

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))")
}
[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にプッシュトークンを登録する

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

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

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

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

[AppDelegate.braze.notifications registerDeviceToken:deviceToken];

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

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

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

Brazeのデフォルトプッシュ処理を有効にするには、アプリのapplication(_:didReceiveRemoteNotification:fetchCompletionHandler:)メソッドに以下のコードを追加します。

if let braze = AppDelegate.braze, braze.notifications.handleBackgroundNotification(
  userInfo: userInfo,
  fetchCompletionHandler: completionHandler
) {
  return
}
completionHandler(.noData)

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

if let braze = AppDelegate.braze, braze.notifications.handleUserNotification(
  response: response,
  withCompletionHandler: completionHandler
) {
  return
}
completionHandler()

Brazeのデフォルトプッシュ処理を有効にするには、アプリケーションのapplication:didReceiveRemoteNotification:fetchCompletionHandler:メソッドに以下のコードを追加します。

BOOL processedByBraze = AppDelegate.braze != nil && [AppDelegate.braze.notifications handleBackgroundNotificationWithUserInfo:userInfo
                                                                                                       fetchCompletionHandler:completionHandler];
if (processedByBraze) {
  return;
}

completionHandler(UIBackgroundFetchResultNoData);

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

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がプッシュクリックイベントをログに記録します。

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がプッシュクリックイベントをログに記録します。

- (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ドキュメントを参照して、どのエンドポイントにリクエストを行うかを確認してください。

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パラメーターを使用して、プッシュ開封イベント、プッシュ受信イベント、またはその両方に関連する通知を購読するかどうかを指定できます。

// 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)'")
}
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 によってコントロールされます。

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のカスタマイズなしで行うことができます。

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

ダイナミックApple Push Notification Service(APNs)ゲートウェイ管理は、正しいAPNs環境を自動的に検出することで、iOSプッシュ通知の信頼性と効率を向上させます。以前は、プッシュ通知のAPNs環境(開発または本番)を手動で選択する必要があり、ゲートウェイの設定ミス、配信の失敗、BadDeviceTokenエラーが発生することがありました。

ダイナミックAPNsゲートウェイ管理により、以下のメリットが得られます。

  • 信頼性の向上:通知は常に正しいAPNs環境に配信されるため、配信失敗が減少します。
  • 設定の簡素化:APNsゲートウェイ設定を手動で管理する必要がなくなります。
  • エラー耐性:無効または欠落したゲートウェイ値は適切に処理され、中断のないサービスが提供されます。

前提条件

Brazeは、以下のSDKバージョン要件を満たすiOSでのプッシュ通知に対して、ダイナミックAPNsゲートウェイ管理をサポートしています。

仕組み

iOSアプリがBraze Swift SDKと統合されると、aps-environmentを含むデバイス関連データが、利用可能な場合にBraze SDK APIに送信されます。apns_gatewayの値は、アプリが開発(dev)または本番(prod)のAPNs環境を使用しているかを示します。

Brazeは各デバイスについて報告されたゲートウェイの値も保存します。新しい有効なゲートウェイの値を受信すると、Brazeは保存された値を自動的に更新します。

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

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

よくある質問

この機能が導入された理由は何ですか?

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

この機能はプッシュ配信のパフォーマンスにどのような影響がありますか?

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

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

ダイナミックAPNsゲートウェイ管理はデフォルトで有効になっており、信頼性の向上を提供します。手動でのゲートウェイ選択が必要な特定のユースケースがある場合は、Brazeサポートにお問い合わせください。

Android TVのプッシュ通知について

Android TVプッシュ通知ガイドで使用されるAndroid TVデバイスのイラスト

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

前提条件

この機能を使用するには、以下を完了する必要があります。

プッシュ通知の設定

Android TVのプッシュ通知を設定するには、以下の手順に従います。

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

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

Android TVプッシュ通知のテスト

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

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

ベストプラクティス

Brazeを使用するマーケターにとって、Android TVへのキャンペーン配信は、Androidモバイルアプリへのプッシュ配信と同じです。これらのデバイスのみをターゲットにするには、セグメンテーションでAndroid TVアプリを選択してください。

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

前提条件

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

プッシュディープリンクを有効にする

デフォルトでは、Braze Cordova SDKはプッシュ通知からのディープリンクを自動的に処理しません。プッシュディープリンクを有効にするには、ディープリンクの設定ステップに従ってください。 これらおよびその他のプッシュ設定オプションの詳細については、オプション設定を参照してください。

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

Braze Cordova SDKをiOS向けに統合すると、基本的なプッシュ通知機能がデフォルトで有効になります。iOSアプリでこの機能を無効にするには、config.xmlファイルに以下を追加してください。詳細については、オプションの設定を参照してください。

<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にアクセスし、プロジェクトを開き、 Settings > Project settingsを選択します。

「Settings」メニューが開いた状態のFirebaseプロジェクト。

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

「Sender ID」がハイライトされたFirebaseプロジェクトの「Cloud Messaging」ページ。

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

braze.xmlファイルに以下を追加します。FIREBASE_SENDER_IDを先ほどコピーしたSender IDに置き換えてください。

<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: APNs証明書をアップロードする

Apple Push Notification service(APNs)証明書を生成し、Brazeダッシュボードにアップロードします。詳細な手順については、APNs証明書のアップロードを参照してください。

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

ネイティブiOS統合ガイドに従ってください。

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

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

// 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();

プッシュ通知イベントフィールド

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

フィールド名 説明
payloadType String 通知ペイロードタイプを指定します。Braze Flutter SDKから送信される2つの値はpush_openedpush_receivedです。iOSではpush_openedイベントのみがサポートされています。
url String 通知によって開かれたURLを指定します。
useWebview Boolean trueの場合、URLはアプリ内のモーダルWebビューで開かれます。falseの場合、URLはデバイスブラウザーで開かれます。
title String 通知のタイトルを表します。
body String 通知の本文またはコンテンツテキストを表します。
summaryText String 通知のサマリーテキストを表します。iOSではsubtitleからマッピングされます。
badgeCount Number 通知のバッジカウントを表します。
timestamp Number アプリケーションがペイロードを受信した時刻を表します。
isSilent Boolean trueの場合、ペイロードはサイレントに受信されます。Androidのサイレントプッシュ通知の送信について詳しくは、Androidでのサイレントプッシュ通知を参照してください。iOSのサイレントプッシュ通知の送信について詳しくは、iOSでのサイレントプッシュ通知を参照してください。
isBrazeInternal Boolean フィーチャーフラグの同期やアンインストール追跡など、内部SDK機能のために通知ペイロードが送信された場合、これはtrueになります。ペイロードはユーザーに対してサイレントに受信されます。
imageUrl String 通知画像に関連付けられたURLを指定します。
brazeProperties Object キャンペーンに関連付けられたBrazeプロパティ(キーと値のペア)を表します。
ios Object iOS固有のフィールドを表します。
android Object Android固有のフィールドを表します。

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

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

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

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

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

このフラグは、ネイティブAndroidコードのランタイム設定を通じて設定することもできます。

val brazeConfig = BrazeConfig.Builder()
        .setHandlePushDeepLinksAutomatically(true)
        .build()
Braze.configure(this, brazeConfig)

ディープリンクをカスタムで処理したい場合は、ステップ2で説明したsubscribeToPushNotificationEvents()リスナーを使用して、push_openedイベントのurlフィールドを自分でルーティングしてください。詳しくは、ディープリンクを参照してください。

前提条件

この機能を使用する前に、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をメモしてください。

App IDとApp secretが表示されているHuawei開発者コンソールのアプリ情報ページ。

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

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

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

Android Huaweiアプリを作成するBrazeのAdd Appダイアログ。

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

Huawei App IDとClient Secretフィールドを含むBrazeのHuaweiプッシュプロバイダー設定。

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

Huaweiは、Huawei Messaging Serviceをアプリケーションに統合するためのAndroid統合コードラボを提供しています。まずはこのステップに従ってください。

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

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
    }
  }
}
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に以下を追加します:

<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 Pushを選択します。

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

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

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

テストタブで、changeUser(USER_ID_STRING)メソッドを使用してアプリ内で設定したユーザーIDを入力し、Send Testをクリックしてテストプッシュを送信します。

キャンペーン作成コンポーザーのテストタブ。ユーザーIDを入力し、「Add Individual Users」フィールドに入力することで自分自身にテストメッセージを送信できます。

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

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

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

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

プッシュターゲティング用にHuaweiアプリを選択するBrazeのセグメントアプリフィルター。

もちろん、同じプッシュをすべての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に移動し、プロジェクトを開いて、 Settings > Project settingsを選択します。

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

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

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

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

"firebaseCloudMessagingSenderId": "693679403398"

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

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

{
  "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には影響しません。

const permissionOptions = {
  alert: true,
  sound: true,
  badge: true,
  provisional: false
};

Braze.requestPushPermission(permissionOptions);

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

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

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));
});
プッシュ通知イベントフィールド

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

フィールド名 タイプ 説明
payload_type 文字列 通知ペイロードのタイプを指定します。Braze React Native SDKから送信される2つの値は push_openedpush_received です。
url 文字列 通知によって開かれたURLを指定します。
use_webview ブール値 true の場合、URLはアプリ内のモーダルウェブビューで開かれます。false の場合、URLはデバイスのブラウザーで開かれます。
title 文字列 通知のタイトルを表します。
body 文字列 通知の本文またはコンテンツテキストを表します。
summary_text 文字列 通知の要約テキストを表します。これはiOSでは subtitle からマッピングされます。
badge_count 数値 通知のバッジカウントを表します。
timestamp 数値 ペイロードがアプリケーションによって受信された時刻を表します。
is_silent ブール値 true の場合、ペイロードはサイレントに受信されます。Androidのサイレントプッシュ通知の送信の詳細については、Androidでのサイレントプッシュ通知を参照してください。iOSのサイレントプッシュ通知の送信の詳細については、iOSでのサイレントプッシュ通知を参照してください。
is_braze_internal ブール値 フィーチャーフラグ同期やアンインストール追跡などの内部SDK機能に対して通知ペイロードが送信された場合、これは true になります。ペイロードはユーザーに対してサイレントに受信されます。
image_url 文字列 通知画像に関連するURLを指定します。
braze_properties オブジェクト キャンペーンに関連するBrazeプロパティ(キーと値のペア)を表します。
ios オブジェクト iOS固有のフィールドを表します。
android オブジェクト Android固有のフィールドを表します。

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

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

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

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

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

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

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

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

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

// 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 を追加します。以下に例を示します。

- (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];
}
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 の値を取得します。これにより、アプリが起動していない状態でプッシュ通知からアプリを開くディープリンクに対応できます。以下に例を示します。

// 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を開くかどうかを判断するBrazeデリゲートを実装し、それをBrazeインスタンスに登録します。

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

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 を作成し登録します。

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 ファイルを作成し、以下のコードスニペットを追加します。

#import <Foundation/Foundation.h>
#import <BrazeKit/BrazeKit-Swift.h>

@interface BrazeReactDelegate: NSObject<BrazeDelegate>

@end

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

#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 を作成し登録します。

#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;
}

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

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

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

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

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

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

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

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

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を指定できます。例えば以下のように設定します。

{
  "expo": {
    "plugins": [
      [
        "@braze/expo-plugin",
        {
          ...
          "androidFirebaseMessagingFallbackServiceEnabled": true,
          "androidFirebaseMessagingFallbackServiceClasspath": "com.company.OurFirebaseMessagingService"
        }
      ]
    ]
  }
}

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

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

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

トラブルシューティング

以下は、Braze React Native SDKとExpoプラグインを使用したプッシュ通知統合に関する一般的なトラブルシューティング手順です。

プッシュ通知が動作しなくなった場合

Expoプラグインを通じたプッシュ通知が動作しなくなった場合:

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

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

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

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

移行後にプッシュ通知からのディープリンクが開かなくなった場合は、以下を確認してください。

  1. アップグレードしたアプリでReact Native Linkingの設定がまだ有効であることを確認します。
  2. iOSネイティブ統合の場合、populateInitialPayloadFromLaunchOptionsBraze.getInitialPushPayloadを実装していることを確認してください。これにより、アプリが終了状態から起動された際に、初期プッシュペイロードを取得してそのurlをディープリンクハンドラーに渡すことができます。
  3. Braze Expoプラグインを使用している場合、androidHandlePushDeepLinksAutomaticallyが実装に合わせて正しく設定されていることを確認します。
  4. 最近追加された依存関係が通知処理やアプリデリゲートの動作をオーバーライドしていないか確認します。

これらの確認を完了しても問題が解決しない場合は、サポートチケットを開き、SDKログと再現手順を添えてください。

前提条件

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

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

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

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

例えば、App Switcherが使用するバックグラウンドテーマの色やアイコン、ネイティブアプリのようにフルスクリーンで表示するかどうか、アプリを横向きモードで開くか縦向きモードで開くかを設定できます。

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

{
  "name": "your app name",
  "short_name": "your app name",
  "display": "fullscreen",
  "icons": [{
    "src": "favicon.ico",
    "sizes": "128x128",
  }]
}

サポートされているフィールドの完全なリストは、MDNのWebアプリマニフェストドキュメントを参照してください。

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

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

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

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

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

主要なブラウザー(Safari、Chrome、FireFox、Edgeなど)は、いずれも新しいバージョンでWebプッシュ通知をサポートしています。iOSまたはiPadOSでプッシュ許可をリクエストするには、共有 > ホーム画面に追加を選択して、Webサイトをユーザーのホーム画面に追加する必要があります。ホーム画面に追加を使用すると、ユーザーはWebサイトをブックマークし、ホーム画面にアイコンを追加できます。

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

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

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

通知を「許可」または「許可しない」を尋ねるプッシュプロンプト

例:

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サーバーキーとSender IDをBrazeダッシュボードに入力する必要があります。これを行うには、Firebase Developers Consoleにログインし、Firebaseプロジェクトを選択します。次に、Settingsの下にあるCloud Messagingを選択し、サーバーキーとSender IDをコピーします。
FirebaseコンソールのCloud Messaging設定。サーバーキーとSender IDが表示されています。

Brazeで、設定の管理アプリ設定ページからAndroidアプリを選択します。次に、Firebase Cloud Messaging Server KeyフィールドにFirebaseサーバーキーを、Firebase Cloud Messaging Sender IDフィールドにFirebase Sender IDを入力します。

BrazeのAndroidアプリ設定。Firebase Cloud Messagingサーバーキーと送信者IDのフィールドが表示されています。

ステップ1.1: 統合方法を確認する

BrazeはiOSプッシュ統合を自動化するためのネイティブUnityソリューションを提供しています。統合を手動で設定・管理したい場合は、Swift: プッシュ通知を参照してください。

それ以外の場合は、次のステップに進んでください。

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

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

ステップ2: プッシュ通知を設定する

ステップ2.1: プッシュ設定を構成する

Braze SDKはFirebase Cloud Messagingサーバーへのプッシュ登録を自動的に処理し、デバイスがプッシュ通知を受信できるようにします。UnityでAutomate Unity Android Integrationを有効にし、次のPush Notification設定を構成します。

設定 説明
Automatic Firebase Cloud Messaging Registration Enabled Braze SDKに対し、デバイスのFCMプッシュトークンを自動的に取得・送信するよう指示します。
Firebase Cloud Messaging Sender ID FirebaseコンソールのSender IDです。
Handle Push Deeplinks Automatically プッシュ通知がクリックされた際に、SDKがディープリンクの開封やアプリの起動を処理するかどうかを設定します。
Small Notification Icon Drawable プッシュ到着時に表示される小アイコンのAndroid drawableリソース参照です。@drawable/プレフィックスを含む完全な参照を入力します(例:@drawable/hourglass_icon)。自動統合はこの値をそのままbraze.xmlに書き込みます。空のままにすると、通知はアプリケーションアイコンを小アイコンとして使用します。
Large Notification Icon Drawable 通知用のオプションの大アイコンです。小アイコンと同じ@drawable/形式を使用します(例:@drawable/my_large_icon)。

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

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

  1. Apple開発者アカウントで、Certificates, Identifiers & Profilesにアクセスします。
  2. KeysAllを選択し、ページ上部の追加ボタン(+)をクリックします。
  3. Key Descriptionで、署名キーの一意の名前を入力します。
  4. Key ServicesApple Push Notification service (APNs)チェックボックスをオンにし、Continueをクリックします。Confirmをクリックします。
  5. キーIDをメモしておきます。Downloadをクリックして、キーを生成してダウンロードします。ダウンロードしたファイルは安全な場所に保存してください。このファイルは一度しかダウンロードできません。
  6. Brazeで、設定 > アプリ設定に移動し、Apple Push Certificate.p8ファイルをアップロードします。開発用または本番用のプッシュ証明書のいずれかをアップロードできます。アプリがApp Storeで公開された後にプッシュ通知をテストするには、アプリの開発バージョン用に別のワークスペースを設定することをお勧めします。
  7. プロンプトが表示されたら、アプリのバンドルIDキーIDチームIDを入力します。また、アプリの開発環境と本番環境のどちらに通知を送信するかを指定する必要があります。これはプロビジョニングプロファイルによって定義されます。
  8. 完了したら、保存を選択します。

ステップ2.2: 自動プッシュを有効にする

UnityエディターでBraze > Braze Configurationに移動して、Braze設定を開きます。

Integrate Push With Brazeにチェックを入れると、プッシュ通知へのユーザー登録の自動化、Brazeへのプッシュトークンの受け渡し、プッシュ開封の分析トラッキング、およびデフォルトのプッシュ通知処理の活用が行われます。

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

プッシュ通知のbackground modeを有効にしたい場合は、Enable Background Pushにチェックを入れます。これにより、プッシュ通知の到着時にシステムがsuspended状態からアプリケーションを起動し、プッシュ通知に応じてコンテンツをダウンロードできるようになります。このオプションにチェックを入れることは、アンインストール追跡機能に必要です。

UnityエディターのBraze設定オプション。「Automate Unity iOS integration」、「Integrate push with braze」、「Enable background push」が有効になっています。

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

プッシュ通知をまだオプトインしていないユーザーは、アプリを開いた時点で自動的にプッシュの承認が行われます。この機能を無効にし、手動でユーザーをプッシュ登録するには、Disable Automatic Push Registrationにチェックを入れます。

  • iOS 12以降でDisable Provisional Authorizationにチェックが入っていない場合、ユーザーは仮(サイレント)承認され、静かなプッシュを受信します。チェックが入っている場合、ユーザーにはネイティブのプッシュプロンプトが表示されます。
  • プロンプトの表示タイミングを実行時に正確に制御する必要がある場合は、Braze設定エディターで自動登録を無効にし、代わりにAppboyBinding.PromptUserForPushPermissions()を使用してください。

UnityエディターのBraze設定オプション。「Automate Unity iOS integration」、「integrate push with braze」、「disable automatic push registration」が有効になっています。

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

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

<?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キーを生成し、api_key.txtという名前のファイルにキーを保存して、プロジェクトのAssets/ディレクトリに追加します。

次に、mainTemplate.gradleファイルに以下を追加します。

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 Jarを追加する

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

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

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

BrazeのFire OSアプリ設定ページ。ADMクライアントIDとクライアントシークレットのフィールドが表示されています。

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

ステップ3.1: プッシュ受信リスナーを有効にする

プッシュ受信リスナーは、ユーザーがプッシュ通知を受信したときに発火します。プッシュペイロードをUnityに送信するには、Set Push Received Listenerでゲームオブジェクトの名前とプッシュ受信リスナーのコールバックメソッドを設定します。

ステップ3.2: プッシュ開封リスナーを有効にする

プッシュ開封リスナーは、ユーザーがプッシュ通知をクリックしてアプリを起動したときに発火します。プッシュペイロードをUnityに送信するには、Set Push Opened Listenerでゲームオブジェクトの名前とプッシュ開封リスナーのコールバックメソッドを設定します。

ステップ3.3: プッシュ削除リスナーを有効にする

プッシュ削除リスナーは、ユーザーがプッシュ通知をスワイプして消去した場合に発火します。プッシュペイロードをUnityに送信するには、Set Push Deleted Listenerでゲームオブジェクトの名前とプッシュ削除リスナーのコールバックメソッドを設定します。

プッシュリスナーの例

以下の例では、コールバックメソッド名PushNotificationReceivedCallbackPushNotificationOpenedCallbackPushNotificationDeletedCallbackを使用してBrazeCallbackゲームオブジェクトを実装しています。

この実装例のグラフィックは、前述のセクションで説明したBraze設定オプションとC#コードスニペットを示しています。

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設定オプション。「Set Push Received Listener」オプションが展開され、「Game Object Name」(AppBoyCallback)と「Callback Method Name」(PushNotificationReceivedCallback)が入力されています。

ステップ3.2: プッシュ開封リスナーを有効にする

プッシュ開封リスナーは、ユーザーがプッシュ通知をクリックしてアプリを起動したときに発火します。プッシュペイロードをUnityに送信するには、Set Push Opened Listenerオプションでゲームオブジェクトの名前とプッシュ開封リスナーのコールバックメソッドを設定します。

UnityエディターのBraze設定オプション。「Set Push Received Listener」オプションが展開され、「Game Object Name」(AppBoyCallback)と「Callback Method Name」(PushNotificationOpenedCallback)が入力されています。

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

プッシュリスナーの例

以下の例では、コールバックメソッド名PushNotificationReceivedCallbackPushNotificationOpenedCallbackを使用してAppboyCallbackゲームオブジェクトを実装しています。

この実装例のグラフィックは、前述のセクションで説明したBraze設定オプションとC#コードスニペットを示しています。

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を更新した際に、以下の行を追加したことでプッシュリスナーが自動的に設定されています。そのため、追加のセットアップは不要です。

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

オプション設定

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

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

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

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

プッシュアイコンをプロジェクトに追加するには、res/drawable*(または密度固有のフォルダー)にアイコン画像ファイルを含むAARプラグインまたはAndroidライブラリを作成し、Braze > Braze Configurationでフルの@drawable/リソース名を使用して各アイコンを参照します(ステップ2.1:プッシュ設定を構成するを参照)。Unityのパッケージ化とインポート手順については、Android Library Projects and Android Archive plug-insを参照してください。

小アイコンのアートワークルール(アルファのみ、色なし)については、Androidプッシュ通知のステップ2:小アイコンをデザインガイドラインに準拠させるを参照してください。

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

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

現時点では、ADMのオプション設定はありません。

前提条件

この機能を使用する前に、.NET MAUI Braze SDKの統合を完了する必要があります。

プッシュ通知の設定

.NET MAUI(旧Xamarin)のプッシュ通知を統合するには、ネイティブAndroidプッシュ通知のステップを完了する必要があります。以下のステップは概要のみです。完全なウォークスルーについては、ネイティブプッシュ通知ガイドを参照してください。

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

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

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

  1. Google CloudでFirebase Cloud Messaging APIを有効にします。
  2. Service Accounts > プロジェクトを選択 > Create Service Accountを選択し、サービスアカウント名、ID、および説明を入力します。完了したら、Create and continueを選択します。
  3. Roleフィールドで、ロールのリストからFirebase Cloud Messaging API Adminを見つけて選択します。
  4. Service Accountsでプロジェクトを選択し、 Actions > Manage Keys > Add Key > Create new keyを選択します。JSONを選択し、Createを選択します。

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

  1. Brazeで、 設定 > アプリ設定を選択します。Androidアプリのプッシュ通知設定で、Firebaseを選択し、JSONファイルをアップロードを選択して、先ほど生成した認証情報をアップロードします。完了したら、保存を選択します。
  2. Firebase Consoleに移動して、自動FCMトークン登録を有効にします。プロジェクトを開き、 Settings > Project settingsを選択します。Cloud Messagingを選択し、Firebase Cloud Messaging API (V1)の下で、Sender IDフィールドの番号をコピーします。
  3. Android Studioプロジェクトで、braze.xmlに以下を追加します。
  <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インスタンス設定に以下のコードを追加して、プッシュオートメーションと許可を設定します:

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

詳細については、iOS MAUIサンプルアプリケーションを参照してください。また、XamarinのドキュメントEnhanced User Notifications in Xamarin.iOSも参照してください。

New Stuff!