Voraussetzungen
- Grundlegendes Verständnis von Laravel
- Grundlegendes Verständnis von APIs
- Einige Kenntnisse über CURL oder GuzzleHTTP
- Wissen Sie, was FCM ist?
- Firebase Konto und Projekt einrichten
Projekt einrichten
Richten Sie eine neue Laravel-Anwendung ein, indem Sie den folgenden Befehl ausführen.
laravel new fcm-notifications
Vorbereitung der Probe Nutzlast
{
"payload": {
"a": "b",
"c": "d",
"e": "f"
},
"receiver_user": "receiver_fcm_registeration_id",
"sender_user": "sender_fcm_registeration_id",
"title":"sample title",
"message":"sample message",
"push_type":"individual"
}- Nutzdaten sind die Muster-Nutzdaten, die durch die Bereitstellung benutzerdefinierter Musterdaten bereitgestellt werden.
- Receiver User ist die FCM-Registrierungs-ID des Benutzers, an den Sie die Benachrichtigung senden möchten.
- Absender Benutzer ist die FCM-Registrierungs-ID des Benutzers, der die Benachrichtigung sendet (optional)
- Titel für die Benachrichtigung
- Nachricht für die Benachrichtigung
- Post Type ist entweder Individual für einen einzelnen Benutzer, Topic für das Senden an ein Topic oder Multiple für das Senden an mehrere Benutzer.
API-Endpunkt
Für diese Aufgabe benötigen wir nur einen einfachen POST-API-Endpunkt zum Senden von FCM-Benachrichtigungen an Benutzer.
Gehen Sie zum Projektordner und öffnen Sie routes/api.php und fügen Sie unsere POST-Route zu einigen NotificationController, die wir später erstellen werden.
Route::post( 'notify', 'NotificationController@notify' );
Erstellen wir nun einen Controller und eine darin enthaltene Notify-Methode mit der artisan-Befehlszeile.
php artisan make:controller NotificationController
Holen wir nun diese Beispiel-Nutzlast aus der Anfrage in Ihrem Controller app\Http\Controllers\NotificationController.php etwa so,
public function notify() {
$data = json_decode( \request()->getContent() );
$sender = $data->sender_user;
$receiver = $data->receiver_user;
$notification_payload = $data->payload;
$notification_title = $data->title;
$notification_message = $data->message;
$notification_push_type = $data->push_type;
}FCM und Push-Benachrichtigung einrichten
Bevor wir weitermachen, sollten wir hier kurz innehalten und uns überlegen, was als Nächstes ansteht. Um jetzt eine FCM-Benachrichtigung zu senden, brauchen wir eine Art von Mechanismus, der funktioniert. Um eine einfache Lösung zu finden, erstellen wir hier ein paar Dateien: Firebase.php und Push.php
Firebase.php ist für das Versenden von Nachrichten zuständig und kümmert sich um den Push-Typ der Nachricht, die Sie versenden möchten.
Push.php ist für die Einstellung der Daten aus der Beispiel-Nutzlast verantwortlich und setzt unser endgültiges JSON für die Benachrichtigung.
Lassen Sie uns jetzt unsere Dateien erstellen. Wir packen sie in app\Libraries Namensraum.
Jetzt in unserem Firebase.php, fügen Sie die folgenden Methoden hinzu.
class Firebase {
/**
* Sending push message to single user by Firebase Registration ID
* @param $to
* @param $message
*
* @return bool|string
*/
public function send( $to, $message ) {
$fields = array(
'to' => $to,
'data' => $message,
);
return $this->sendPushNotification( $fields );
}
/**
* Sending message to a topic by topic name
* @param $to
* @param $message
*
* @return bool|string
*/
public function sendToTopic( $to, $message ) {
$fields = array(
'to' => '/topics/' . $to,
'data' => $message,
);
return $this->sendPushNotification( $fields );
}
/**
* Sending push message to multiple users by firebase registration ids
* @param $registration_ids
* @param $message
*
* @return bool|string
*/
public function sendMultiple( $registration_ids, $message ) {
$fields = array(
'to' => $registration_ids,
'data' => $message,
);
return $this->sendPushNotification( $fields );
}
/**
* CURL request to firebase servers
* @param $fields
*
* @return bool|string
*/
private function sendPushNotification( $fields ) {
// Set POST variables
$url = 'https://fcm.googleapis.com/fcm/send';
$headers = array(
'Authorization: key=' . env('FCM_LEGACY_KEY')',
'Content-Type: application/json'
);
// Open connection
$ch = curl_init();
// Set the url, number of POST vars, POST data
curl_setopt( $ch, CURLOPT_URL, $url );
curl_setopt( $ch, CURLOPT_POST, true );
curl_setopt( $ch, CURLOPT_HTTPHEADER, $headers );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
// Disabling SSL Certificate support temporarly
curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, false );
curl_setopt( $ch, CURLOPT_POSTFIELDS, json_encode( $fields ) );
// Execute post
$result = curl_exec( $ch );
if ( $result === false ) {
die( 'Curl failed: ' . curl_error( $ch ) );
}
// Close connection
curl_close( $ch );
return $result;
}Diese Firebase-Klasse ist ziemlich einfach zu bekommen. Es ist nur eine Sammlung von Methoden für das Senden von Push-Benachrichtigungen. Hier, wenn Sie bemerkt haben, müssen Sie hinzufügen FCM_LEGACY_KEY, die wir aus unserer .env-Datei erhalten.
Sie können Ihre FCM_LEGACY_KEY in Ihrer FCM-Konsole unter Ihren Projekteinstellungen auf der Registerkarte Cloud Messaging.
Jetzt für Push.php,
class Push {
private $title;
private $message;
private $data;
/**
* @param $title
*/
public function setTitle( $title ) {
$this->title = $title;
}
/**
* @param $message
*/
public function setMessage( $message ) {
$this->message = $message;
}
/**
* @param $data
*/
public function setPayload( $data ) {
$this->data = $data;
}
/**
* @return array
*/
public function getPush() {
$response = array();
$response['data']['title'] = $this->title;
$response['data']['message'] = $this->message;
$response['data']['payload'] = $this->data;
$response['data']['timestamp'] = date( 'Y-m-d G:i:s' );
return $response;
}
}Hier geben wir unsere Daten, den Titel und die Nachricht usw. ein. Ziemlich einfach, oder?
Zurück zu NotificationController
In unserem notify Methode fügen Sie den folgenden Code unter data.
try {
$sender_id = "";
$receiver_id = "";
$firebase = new Firebase();
$push = new Push();
// optional payload
$payload = $notification_payload;
$title = $notification_title ?? '';
// notification message
$message = $notification_message ?? '';
// push type - single user / topic
$push_type = $notification_push_type ?? '';
$push->setTitle( $title );
$push->setMessage( $message );
$push->setPayload( $payload );
$json = '';
$response = '';
if ( $push_type === 'topic' ) {
$json = $push->getPush();
$response = $firebase->sendToTopic( 'global', $json );
} else if ( $push_type === 'individual' ) {
$json = $push->getPush();
$regId = $receiver_id ?? '';
$response = $firebase->send( $regId, $json );
return response()->json( [
'response' => $response
] );
}
} catch ( \Exception $ex ) {
return response()->json( [
'error' => true,
'message' => $ex->getMessage()
] );
}Endlich
Wenn also alles gut gegangen ist und Sie es in Postman oder Ihrer Anwendung testen. Sie werden eine Antwort wie diese erhalten,
{
"response": {
"multicast_id": 7537747549381668791,
"success": 1,
"failure": 0,
"canonical_ids": 0,
"results": [
{
"message_id": "0:1562948236493630%12bb27e9f9fd7ecd"
}
]
}
}Zusätzlich
Wenn Ihnen der CURL-Teil nicht gefällt. Wir haben hier etwas für Sie. Lassen Sie uns ein wenig refaktorisieren und den CURL-Aufruf in GuzzleHTTP umwandeln.
Installieren Sie das Paket durch Ausführen von
composer require guzzlehttp/guzzle
Jetzt ersetzen wir den Code in unserem sendPushNotification Funktion in Firebase.php
Aktualisiert sendPushNotification Funktion würde nun wie folgt aussehen:
private function sendPushNotification( $fields ) {
// Set POST variables
$url = 'https://fcm.googleapis.com/fcm/send';
$client = new Client();
$result = $client->post( $url, [
'json' =>
$fields
,
'headers' => [
'Authorization' => 'key='.env('FCM_LEGACY_KEY'),
'Content-Type' => 'application/json',
],
] );
return json_decode( $result->getBody(), true );
}Ziemlich sauber? Vergessen Sie auch nicht, Folgendes zu verwenden GuzzleHttp\Client am Anfang der Klasse.
Schlussfolgerung
Nun, wir haben erfolgreich FCM-Benachrichtigungen mit Laravel implementiert. Wenn Sie zwischendurch auf Fehler gestoßen sind, lassen Sie es uns bitte in den Kommentaren unten wissen. Den kompletten Code finden Sie auf der Github.
