Flutter Dynamic Island & Live Activities: iOS/Android Guide

Limitations of Standard Push Notifications: Why Live Activities?

When delivering dynamic, real-time status updates to users—such as food delivery progress, taxi/ride-hailing routes, live sports scores, active timers, or commute tracking—developers traditionally relied on standard Push Notifications.

However, standard push notifications come with critical limitations:

[Traditional Push Notification Approach]
- Messages stack up in the notification center on every event -> Notification Fatigue
- Once closed, users cannot check updated status without reopening the app
- High latency and disconnected user engagement flow

Introduced in iOS 16.1+ and cemented as a core mobile UI primitive in iOS 18 and 19, Live Activities and the Dynamic Island completely shifted this paradigm.

By implementing Live Activities, you can update real-time application state through a single, persistent widget—even when your app is in the background or the device is on the Lock Screen. Production app metrics show that services implementing Live Activities achieve over a 40% increase in app re-engagement.

In this guide, you will learn how to integrate iOS Swift ActivityKit & WidgetKit into a Flutter application. We’ll cover building all four Dynamic Island layouts (Compact Leading/Trailing, Expanded, and Minimal) and driving real-time state updates from an edge server using APNs (Apple Push Notification service) push tokens.

Live Activities & Dynamic Island Architecture Overview

While your Flutter app renders its main UI, Dynamic Island and Lock Screen widgets run inside the native iOS SwiftUI / WidgetKit / ActivityKit runtime.

+-----------------------------------------------------------------------------------+
| Flutter Live Activities & APNs Real-Time Update Pipeline                          |
+-----------------------------------------------------------------------------------+

[Flutter App Engine]             [iOS Native Host (Swift)]           [Cloudflare / APNs Server]
         |                                   |                                   |
         |--- 1. Start Activity (MethodChannel)->|                               |
         |                                   |--- 2. Create ActivityKit Widget->| (Lock Screen / Island)
         |                                   |--- 3. Obtain Push Token --------->|
         |                                   |                                   | (Save token to server DB)
         |                                   |                                   |
         |                                   |--- 4. Send APNs Push Payload
         |                                   |<-- 5. Real-Time Status Update -----|

1. Start Activity: When an order or timer starts, the Flutter app invokes Swift ActivityKit via a MethodChannel.
2. Obtain Push Token: The native iOS host creates a dedicated pushToken for that Live Activity instance and sends it to your backend server (e.g., Cloudflare Workers or Firebase).
3. APNs Server Push Update: Even if the app is completely closed (killed), your backend sends state update payloads using the APNs HTTP/2 API, and iOS updates the Dynamic Island immediately.

Step 1: Implementing Native iOS Target & Swift WidgetKit

You need to add a Widget Extension target inside your Flutter project’s ios directory for the Live Activity.

Adding the Xcode Target

1. Open Runner.xcworkspace in Xcode.
2. Go to File > New > Target.
3. Select Widget Extension (Name: LiveActivityWidget, and make sure “Include Live Activity” is checked).

LiveActivityAttributes.swift (Shared Data Structure)

Define the data attributes shared between the Main App and the Widget Extension.

// ios/Runner/LiveActivityAttributes.swift
import ActivityKit
import Foundation

// Immutable static data for the Activity
public struct DeliveryActivityAttributes: ActivityAttributes {
  public struct ContentState: Codable, Hashable {
    // Dynamic data updated in real time
    public var status: String      // "preparing", "onTheWay", "delivered"
    public var driverName: String
    public var estimatedMinutes: Int
    public var progressRatio: Double // 0.0 ~ 1.0
  }

  public var orderId: String
  public var storeName: String
}

LiveActivityWidget.swift (SwiftUI Dynamic Island Layout)

Implement all 4 Dynamic Island presentation states along with the Lock Screen widget view.

// ios/LiveActivityWidget/LiveActivityWidget.swift
import ActivityKit
import WidgetKit
import SwiftUI

@main
struct LiveActivityWidgetBundle: WidgetBundle {
  var body: some Widget {
    DeliveryLiveActivityWidget()
  }
}

struct DeliveryLiveActivityWidget: Widget {
  var body: some WidgetConfiguration {
    ActivityConfiguration(for: DeliveryActivityAttributes.self) { context in
      // 1. Lock Screen widget layout
      LockScreenWidgetView(context: context)
    } dynamicIsland: { context in
      // 2. Dynamic Island 4-view layout
      DynamicIsland {
        // [Expanded] Expanded view shown when long-pressed or expanded
        DynamicIslandExpandedRegion(.leading) {
          HStack {
            Image(systemName: "box.truck.fill")
              .foregroundColor(.purple)
            Text(context.attributes.storeName)
              .font(.caption)
              .bold()
          }
        }
        DynamicIslandExpandedRegion(.trailing) {
          Text("\(context.state.estimatedMinutes)m remaining")
            .font(.headline)
            .foregroundColor(.green)
        }
        DynamicIslandExpandedRegion(.bottom) {
          VStack(alignment: .leading) {
            Text("Driver: \(context.state.driverName)")
              .font(.subheadline)
            ProgressView(value: context.state.progressRatio)
              .tint(.purple)
          }
        }
      } compactLeading: {
        // [Compact Leading] Compact left view (icon)
        Image(systemName: "box.truck.fill")
          .foregroundColor(.purple)
      } compactTrailing: {
        // [Compact Trailing] Compact right view (remaining time)
        Text("\(context.state.estimatedMinutes)m")
          .font(.caption2)
          .bold()
      } minimal: {
        // [Minimal] Minimal view when another app takes over the island
        Image(systemName: "box.truck.fill")
          .foregroundColor(.purple)
      }
    }
  }
}

// Dedicated Lock Screen SwiftUI view
struct LockScreenWidgetView: View {
  let context: ActivityViewContext<DeliveryActivityAttributes>

  var body: some View {
    VStack(alignment: .leading, spacing: 8) {
      HStack {
        Text(context.attributes.storeName)
          .font(.headline)
        Spacer()
        Text(context.state.status)
          .font(.subheadline)
          .foregroundColor(.purple)
      }
      ProgressView(value: context.state.progressRatio)
        .tint(.purple)
      HStack {
        Text("Driver: \(context.state.driverName)")
          .font(.caption)
        Spacer()
        Text("ETA: \(context.state.estimatedMinutes)m")
          .font(.caption)
          .bold()
      }
    }
    .padding()
    .background(Color(uiColor: .systemBackground))
  }
}

Step 2: Building Swift AppDelegate & MethodChannel Handler

Implement a MethodChannel to handle communication between the Flutter engine and native Swift.

// ios/Runner/AppDelegate.swift
import UIKit
import Flutter
import ActivityKit

@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {
  private var currentActivity: Activity<DeliveryActivityAttributes>?

  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    let controller : FlutterViewController = window?.rootViewController as! FlutterViewController
    let channel = FlutterMethodChannel(name: "dev.effidev/live_activity", binaryMessenger: controller.binaryMessenger)

    channel.setMethodCallHandler({ [weak self] (call: FlutterMethodCall, result: @escaping FlutterResult) in
      guard let self = self else { return }

      switch call.method {
      case "startActivity":
        self.startLiveActivity(call: call, result: result)
      case "updateActivity":
        self.updateLiveActivity(call: call, result: result)
      case "endActivity":
        self.endLiveActivity(call: call, result: result)
      default:
        result(FlutterMethodNotImplemented())
      }
    })

    GeneratedPluginRegistrant.register(with: self)
    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }

  // Start Live Activity and capture APNs Push Token
  private func startLiveActivity(call: FlutterMethodCall, result: @escaping FlutterResult) {
    guard ActivityAuthorizationInfo().areActivitiesEnabled else {
      result(FlutterError(code: "DISABLED", message: "Live Activities are disabled", details: nil))
      return
    }

    guard let args = call.arguments as? [String: Any],
          let orderId = args["orderId"] as? String,
          let storeName = args["storeName"] as? String,
          let driverName = args["driverName"] as? String,
          let estimatedMinutes = args["estimatedMinutes"] as? Int else {
      result(FlutterError(code: "INVALID_ARGS", message: "Invalid arguments", details: nil))
      return
    }

    let initialContentState = DeliveryActivityAttributes.ContentState(
      status: "Driver Assigned",
      driverName: driverName,
      estimatedMinutes: estimatedMinutes,
      progressRatio: 0.2
    )

    let activityAttributes = DeliveryActivityAttributes(orderId: orderId, storeName: storeName)

    do {
      let activity = try Activity.request(
        attributes: activityAttributes,
        content: .init(state: initialContentState, staleDate: nil),
        pushType: .token // Enable APNs push updates
      )
      self.currentActivity = activity

      // Listen asynchronously for push token updates and send back to Flutter
      Task {
        for await pushToken in activity.pushTokenUpdates {
          let tokenString = pushToken.map { String(format: "%02x", $0) }.joined()
          print("APNs Live Activity Push Token: \(tokenString)")
          // Pass token to Flutter
          DispatchQueue.main.async {
            result(["activityId": activity.id, "pushToken": tokenString])
          }
          break
        }
      }
    } catch {
      result(FlutterError(code: "ERROR", message: error.localizedDescription, details: nil))
    }
  }

  // Manual local update
  private func updateLiveActivity(call: FlutterMethodCall, result: @escaping FlutterResult) {
    guard let args = call.arguments as? [String: Any],
          let status = args["status"] as? String,
          let estimatedMinutes = args["estimatedMinutes"] as? Int,
          let progressRatio = args["progressRatio"] as? Double else {
      result(FlutterError(code: "INVALID_ARGS", message: "Invalid args", details: nil))
      return
    }

    Task {
      if let activity = self.currentActivity {
        let updatedState = DeliveryActivityAttributes.ContentState(
          status: status,
          driverName: activity.content.state.driverName,
          estimatedMinutes: estimatedMinutes,
          progressRatio: progressRatio
        )
        await activity.update(using: updatedState)
        result(true)
      } else {
        result(false)
      }
    }
  }

  // End Activity
  private func endLiveActivity(call: FlutterMethodCall, result: @escaping FlutterResult) {
    Task {
      if let activity = self.currentActivity {
        let finalState = DeliveryActivityAttributes.ContentState(
          status: "Delivered",
          driverName: activity.content.state.driverName,
          estimatedMinutes: 0,
          progressRatio: 1.0
        )
        await activity.end(using: finalState, dismissalPolicy: .after(Date().addingTimeInterval(5)))
        self.currentActivity = nil
        result(true)
      } else {
        result(false)
      }
    }
  }
}

Step 3: Implementing Flutter Service Layer (live_activity_service.dart)

Create a service wrapper class in Dart to manage the full lifecycle of the Live Activity directly from Flutter.

// lib/services/live_activity_service.dart
import 'dart:async';
import 'package:flutter/services.dart';

class LiveActivityService {
  static const MethodChannel _channel = MethodChannel('dev.effidev/live_activity');

  /// Start Live Activity and obtain APNs Push Token
  static Future<Map<String, String>?> startActivity({
    required String orderId,
    required String storeName,
    required String driverName,
    required int estimatedMinutes,
  }) async {
    try {
      final result = await _channel.invokeMapMethod<String, String>(
        'startActivity',
        {
          'orderId': orderId,
          'storeName': storeName,
          'driverName': driverName,
          'estimatedMinutes': estimatedMinutes,
        },
      );
      return result;
    } on PlatformException catch (e) {
      print('Live Activity Start Error: ${e.message}');
      return null;
    }
  }

  /// Update state locally in foreground
  static Future<bool> updateActivity({
    required String status,
    required int estimatedMinutes,
    required double progressRatio,
  }) async {
    try {
      final success = await _channel.invokeMethod<bool>(
        'updateActivity',
        {
          'status': status,
          'estimatedMinutes': estimatedMinutes,
          'progressRatio': progressRatio,
        },
      );
      return success ?? false;
    } on PlatformException catch (e) {
      print('Live Activity Update Error: ${e.message}');
      return false;
    }
  }

  /// End Live Activity
  static Future<bool> endActivity() async {
    try {
      final success = await _channel.invokeMethod<bool>('endActivity');
      return success ?? false;
    } on PlatformException catch (e) {
      print('Live Activity End Error: ${e.message}');
      return false;
    }
  }
}

Step 4: Edge Serverless (Cloudflare Workers) APNs Push Integration

Even if your app is in the background or killed, calling the APNs (Apple Push Notification service) HTTP/2 API from your backend server updates the Dynamic Island state instantly.

Cloudflare Workers APNs Real-Time Update Handler (src/apns.ts)

// src/apns.ts (Cloudflare Workers / Hono.js)

export interface LiveActivityPushPayload {
  aps: {
    timestamp: number;
    event: "update" | "end";
    "content-state": {
      status: string;
      driverName: string;
      estimatedMinutes: number;
      progressRatio: number;
    };
    "dismissal-date"?: number;
  };
}

export async function sendAPNsLiveActivityUpdate(
  apnsPushToken: string,
  topic: String, // e.g., "dev.effidev.app.push-type.liveactivity"
  payload: LiveActivityPushPayload,
  bearerAuthJwt: string
) {
  // Apple Production APNs Endpoint
  const url = `https://api.push.apple.com/3/device/${apnsPushToken}`;

  const response = await fetch(url, {
    method: "POST",
    headers: {
      "authorization": `bearer ${bearerAuthJwt}`,
      "apns-topic": `${topic}.push-type.liveactivity`, // Required header for Live Activity
      "apns-push-type": "liveactivity",                // Specify liveactivity
      "apns-priority": "10",                           // High priority immediate delivery
      "content-type": "application/json",
    },
    body: JSON.stringify(payload),
  });

  if (!response.ok) {
    const errorText = await response.text();
    console.error(`APNs Push Failed [${response.status}]: ${errorText}`);
    return false;
  }

  console.log(`APNs Live Activity updated successfully for token: ${apnsPushToken}`);
  return true;
}

Android 15+ Live Notifications Support (Ongoing Notification)

The Android ecosystem introduced Ongoing Prominent Notifications starting with Android 15/16 to visualize active background operations in the top status bar.

In Flutter, you can combine ongoing: true and Category.progress via the flutter_local_notifications package to support status bar countdowns and progress indicators on Android.

// Example implementation of Android Ongoing Notification
const AndroidNotificationDetails androidPlatformChannelSpecifics =
    AndroidNotificationDetails(
  'live_delivery_channel',
  'Real-Time Delivery Status',
  channelDescription: 'Displays real-time delivery progress in the top status bar.',
  importance: Importance.max,
  priority: Priority.high,
  ongoing: true, // Persistent notification that cannot be dismissed by swiping
  showProgress: true,
  maxProgress: 100,
  progress: 40,
  category: AndroidNotificationCategory.progress,
);

Production Performance Benchmarks & Battery Optimization Guidelines

Here are the benchmark comparison results measuring key app metrics and resource usage before and after adopting ActivityKit Live Activities.

User Engagement & Resource Metrics

3 Mandatory Battery & Memory Optimization Rules

1. Never Run In-App Background Timers: Running Timer.periodic in a Dart Isolate when the app enters the background causes iOS to terminate your process or severely drain the battery. All state updates must be driven via APNs server push or native OS events.
2. Configure a Stale Date: Set a staleDate when requesting ActivityKit so the OS automatically cleans up stale widgets if no updates occur within a specified window (e.g., 1 hour).
3. Track Push Token Updates: Listen to the pushTokenUpdates stream to ensure updated tokens are saved to your backend database whenever network conditions change.

Conclusion: Bridging the UX Gap with Mobile Architecture

Smartphone users face notification fatigue every day from dozens of repetitive push alerts.

Building Dynamic Island and Live Activities into your Flutter app gives you:

1. Always-Connected UX: Keep your brand and real-time status visible on the Dynamic Island and Lock Screen without requiring users to open the app.
2. Maximized Battery Efficiency: By delegating rendering to iOS SwiftUI widgets instead of running Dart background loops, you protect battery life and system performance.
3. Serverless APNs Update Pipeline: Deliver tens of thousands of state updates globally in sub-100ms via edge backends like Cloudflare Workers.

Integrate Live Activities into your Flutter app today and deliver a seamless experience that boosts user engagement by over 40%.

Related post: Check out our mobile rendering performance guide in Flutter Impeller Engine & Vulkan/Metal Performance Optimization.