Instant Notifications! A Complete Guide to Building Push Notifications in Flutter with Firebase & Go Backend

dependencies:
  flutter:
    sdk: flutter
  firebase_core: ^2.24.2
  firebase_messaging: ^14.7.12

import 'package:flutter/material.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';

// Top-level function to handle background/terminated messages
Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
  await Firebase.initializeApp();
  print("Handling a background message: ${message.messageId}");
  // You can also perform local database storage here if needed
}

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp();

  // Register background message handler
  FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);

  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Push Notification',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({super.key});

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  String? _token;
  String _message = 'No notifications yet';

  @override
  void initState() {
    super.initState();
    _initFirebaseMessaging();
  }

  Future<void> _initFirebaseMessaging() async {
    FirebaseMessaging messaging = FirebaseMessaging.instance;

    // 1. Request Permission (Required for iOS & Web)
    NotificationSettings settings = await messaging.requestPermission(
      alert: true,
      announcement: false,
      badge: true,
      carPlay: false,
      criticalAlert: false,
      provisional: false,
      sound: true,
    );

    print('User granted permission: ${settings.authorizationStatus}');

    // 2. Get Device FCM Token
    String? token = await messaging.getToken();
    setState(() {
      _token = token;
    });
    print("FCM Token: $_token");

    // 3. Listener for Token Refresh
    messaging.onTokenRefresh.listen((newToken) {
      setState(() {
        _token = newToken;
      });
      print("New FCM Token: $newToken");
      // Send this updated token to your backend server!
    }).onError((err) {
      print("Error refreshing token: $err");
    });

    // 4. Handle messages when the app is in Foreground
    FirebaseMessaging.onMessage.listen((RemoteMessage message) {
      print('Got a message whilst in the foreground!');
      print('Message data: ${message.data}');

      if (message.notification != null) {
        print('Message notification: ${message.notification?.title} - ${message.notification?.body}');
        setState(() {
          _message = 'Foreground Notification: ${message.notification?.title ?? ''} - ${message.notification?.body ?? ''}';
        });
      }
    });

    // 5. Handle message when app is opened from Terminated state
    RemoteMessage? initialMessage = await messaging.getInitialMessage();
    if (initialMessage != null) {
      print('App opened from terminated state by notification!');
      setState(() {
        _message = 'Opened from terminated: ${initialMessage.notification?.title ?? ''} - ${initialMessage.notification?.body ?? ''}';
      });
    }

    // 6. Handle message when app is opened from Background state
    FirebaseMessaging.onMessageOpenedApp.listen((RemoteMessage message) {
      print('App opened from background by notification!');
      setState(() {
        _message = 'Opened from background: ${message.notification?.title ?? ''} - ${message.notification?.body ?? ''}';
      });
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Flutter Push Notification'),
      ),
      body: Center(
        child: Padding(
          padding: const EdgeInsets.all(16.0),
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              const Text(
                'Your FCM Token:',
                style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
              ),
              SelectableText(
                _token ?? 'Token unavailable',
                textAlign: TextAlign.center,
                style: const TextStyle(fontSize: 16),
              ),
              const SizedBox(height: 30),
              const Text(
                'Last Notification Status:',
                style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
              ),
              Text(
                _message,
                textAlign: TextAlign.center,
                style: const TextStyle(fontSize: 16, color: Colors.green),
              ),
              const SizedBox(height: 20),
              const Text(
                'Copy the FCM Token above to send notifications from your Go backend!',
                textAlign: TextAlign.center,
                style: TextStyle(fontStyle: FontStyle.italic, color: Colors.grey),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

mkdir go-fcm-backend
cd go-fcm-backend
go mod init go-fcm-backend

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
)

// NotificationRequest defines the structure sent from client to our Go backend
type NotificationRequest struct {
	Token string            `json:"token"` // Target device FCM token
	Title string            `json:"title"`
	Body  string            `json:"body"`
	Data  map[string]string `json:"data,omitempty"` // Optional custom data payload
}

func main() {
	// Retrieve Server Key from Environment Variables for security
	// Usage: export FCM_SERVER_KEY="YOUR_FIREBASE_SERVER_KEY_HERE"
	fcmServerKey := os.Getenv("FCM_SERVER_KEY")
	if fcmServerKey == "" {
		log.Fatal("FCM_SERVER_KEY environment variable not set. Please set it.")
	}

	http.HandleFunc("/send-notification", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
			return
		}

		var req NotificationRequest
		decoder := json.NewDecoder(r.Body)
		if err := decoder.Decode(&req); err != nil {
			http.Error(w, "Invalid request body", http.StatusBadRequest)
			return
		}

		if req.Token == "" {
			http.Error(w, "FCM Token is required", http.StatusBadRequest)
			return
		}

		// Prepare the payload for FCM Legacy Endpoint
		fcmPayload := map[string]interface{}{
			"to": req.Token,
			"notification": map[string]string{
				"title": req.Title,
				"body":  req.Body,
			},
			"data": req.Data,
		}

		payloadBytes, err := json.Marshal(fcmPayload)
		if err != nil {
			http.Error(w, "Failed to marshal FCM payload", http.StatusInternalServerError)
			return
		}

		// Construct HTTP Request to FCM API
		fcmURL := "https://fcm.googleapis.com/fcm/send"
		httpClient := &http.Client{}
		fcmReq, err := http.NewRequest("POST", fcmURL, bytes.NewBuffer(payloadBytes))
		if err != nil {
			http.Error(w, "Failed to create FCM request", http.StatusInternalServerError)
			return
		}

		// Set required headers
		fcmReq.Header.Set("Content-Type", "application/json")
		fcmReq.Header.Set("Authorization", "key="+fcmServerKey)

		// Send request to FCM
		resp, err := httpClient.Do(fcmReq)
		if err != nil {
			http.Error(w, "Failed to send request to FCM", http.StatusInternalServerError)
			return
		}
		defer resp.Body.Close()

		// Read response from FCM
		body, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			log.Printf("Error reading FCM response: %v", err)
			http.Error(w, "Failed to read FCM response", http.StatusInternalServerError)
			return
		}

		log.Printf("FCM Response Status: %s", resp.Status)
		log.Printf("FCM Response Body: %s", string(body))

		if resp.StatusCode != http.StatusOK {
			http.Error(w, fmt.Sprintf("FCM returned error: %s", string(body)), resp.StatusCode)
			return
		}

		w.WriteHeader(http.StatusOK)
		w.Write([]byte("Notification sent successfully!"))
	})

	port := ":8080"
	log.Printf("Go FCM Backend running on port %s", port)
	log.Fatal(http.ListenAndServe(port, nil))
}

# Ensure FCM_SERVER_KEY environment variable is exported
go run main.go

2023/11/27 10:00:00 Go FCM Backend running on port :8080

curl -X POST \
  http://localhost:8080/send-notification \
  -H 'Content-Type: application/json' \
  -d '{
    "token": "PASTE_YOUR_FCM_TOKEN_HERE",
    "title": "Hello from Go Backend!",
    "body": "This is our first push notification via Go!",
    "data": {
      "page": "home",
      "id": "123"
    }
  }'