feat(cloud_functions): add support for cloud functions stream

.github/workflows/scripts/functions/package.json

@@ -14,8 +14,8 @@
   },
   "main": "lib/index.js",
   "dependencies": {
-    "firebase-admin": "^11.5.0",
-    "firebase-functions": "^4.5.0"
+    "firebase-admin": "^13.2.0",
+    "firebase-functions": "^6.3.2"
   },
   "devDependencies": {
     "firebase-functions-test": "^0.2.0",

.github/workflows/scripts/functions/src/index.ts

@@ -2,72 +2,99 @@ import * as assert from 'assert';
 import * as functions from 'firebase-functions';
 import * as functionsv2 from 'firebase-functions/v2';
 
+
 // For example app.
 // noinspection JSUnusedGlobalSymbols
 export const listFruit = functions.https.onCall(() => {
   return ['Apple', 'Banana', 'Cherry', 'Date', 'Fig', 'Grapes'];
 });
 
-export const listfruits2ndgen = functionsv2.https.onCall(() => {
-  return ['Apple', 'Banana', 'Cherry', 'Date', 'Fig', 'Grapes'];
+export const listfruits2ndgen = functionsv2.https.onCall((res, req) => {
+  const fruitList = ['Apple', 'Banana', 'Cherry', 'Date', 'Fig', 'Grapes'];
+  const allFruits = fruitList.map(async (fruit) => {
+    if (res.acceptsStreaming) {
+      req?.sendChunk(fruit)
+    }
+  })
+  return Promise.all(allFruits);
 });
 
 // For e2e testing a custom region.
 // noinspection JSUnusedGlobalSymbols
-export const testFunctionCustomRegion = functions
-  .region('europe-west1')
-  .https.onCall(() => 'europe-west1');
+
+export const testFunctionCustomRegion = functions.https.onCall(
+  {
+    region: 'europe-west1'
+  },
+  () => 'europe-west1'
+);
 
 // For e2e testing timeouts.
-export const testFunctionTimeout = functions.https.onCall((data) => {
+export const testFunctionTimeout = functions.https.onCall((req, res) => {
+  const data = req.data
   console.log(JSON.stringify({ data }));
-  return new Promise((resolve, reject) => {
-    if (data && data.testTimeout) {
-      setTimeout(
-        () => resolve({ timeLimit: 'exceeded' }),
-        parseInt(data.testTimeout, 10)
-      );
-    } else {
-      reject(
-        new functions.https.HttpsError(
-          'invalid-argument',
-          'testTimeout must be provided.'
-        )
-      );
-    }
+
+  const timeoutMs = parseInt(data?.testTimeout, 10);
+
+  if (isNaN(timeoutMs)) {
+    throw new functions.https.HttpsError(
+      'invalid-argument',
+      'testTimeout must be provided.'
+    );
+  }
+
+  if (req.acceptsStreaming) {
+    setTimeout(() => {
+      res?.sendChunk({ timeLimit: 'exceeded' });
+    }, timeoutMs);
+
+    return new Promise((resolve) => {
+      setTimeout(resolve, timeoutMs + 100);
+    });
+  }
+
+  return new Promise((resolve) => {
+    setTimeout(() => resolve({ timeLimit: 'exceeded' }), timeoutMs);
   });
+
 });
 
 // For e2e testing errors & return values.
 // noinspection JSUnusedGlobalSymbols
-export const testFunctionDefaultRegion = functions.https.onCall((data) => {
+export const testFunctionDefaultRegion = functions.https.onCall((req, res) => {
+  const data = req.data;
   console.log(JSON.stringify({ data }));
-  if (typeof data === 'undefined') {
-    return 'undefined';
-  }
+
+  const sendResponse = (value: any) => {
+    if (req.acceptsStreaming && res) {
+      res.sendChunk(value);
+      return value;
+    }
+    return value;
+  };
 
   if (typeof data === 'string') {
-    return 'string';
+    return sendResponse('string');
   }
 
   if (typeof data === 'number') {
-    return 'number';
+    return sendResponse('number');
   }
 
   if (typeof data === 'boolean') {
-    return 'boolean';
+    return sendResponse('boolean');
   }
 
   if (data === null) {
-    return 'null';
+    return sendResponse('null');
   }
 
   if (Array.isArray(data)) {
-    return 'array';
+    return sendResponse('array');
   }
 
-  if(data.type === 'rawData') {
-    return data;
+  if (data.type === 'rawData') {
+    return sendResponse(data);
   }
 
   const sampleData: {
@@ -153,9 +180,45 @@ export const testFunctionDefaultRegion = functions.https.onCall((data) => {
     );
   }
 
-  return outputData;
+  return sendResponse(outputData);
 });
 
 export const testMapConvertType = functions.https.onCall((data) => ({
   foo: 'bar',
 }));
+
+export const testStream = functions.https.onCall((req, res) => {
+  const data = req.data;
+  if (data === null || undefined) {
+    if (req.acceptsStreaming) {
+      res?.sendChunk('null');
+    }
+    return
+  }
+
+  const results = [];
+  results.push(data)
+
+  const allResults = results.map(async (result) => {
+    if (req.acceptsStreaming) {
+      res?.sendChunk(result);
+    }
+    return result;
+  });
+  return Promise.all(allResults);
+})
+
+export const testStreamResponse = functions.https.onCall(async (request, response) => {
+  const fruits = ['Apple', 'Mango', 'Banana']
+
+  const allFruits = fruits.map(async (fruit) => {
+    // Stream each fruit as it resolves!
+    if (request.acceptsStreaming) {
+      response?.sendChunk(fruit);
+    }
+    return fruit;
+  });
+
+  // Fallback for non-streaming clients
+  return Promise.all(allFruits);
+});

packages/cloud_functions/cloud_functions/android/build.gradle

@@ -64,6 +64,7 @@ android {
     implementation platform("com.google.firebase:firebase-bom:${getRootProjectExtOrCoreProperty("FirebaseSDKVersion", firebaseCoreProject)}")
     implementation 'com.google.firebase:firebase-functions'
     implementation 'androidx.annotation:annotation:1.7.0'
+    implementation 'org.reactivestreams:reactive-streams:1.0.4'
   }
 }
 

packages/cloud_functions/cloud_functions/android/src/main/java/io/flutter/plugins/firebase/functions/FirebaseFunctionsStreamHandler.java

@@ -0,0 +1,85 @@
+// Copyright 2025 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package io.flutter.plugins.firebase.functions;
+
+import android.net.Uri;
+import com.google.firebase.functions.FirebaseFunctions;
+import com.google.firebase.functions.HttpsCallableOptions;
+import com.google.firebase.functions.HttpsCallableReference;
+import com.google.firebase.functions.StreamResponse;
+import io.flutter.plugin.common.EventChannel;
+import io.flutter.plugin.common.EventChannel.StreamHandler;
+import java.net.URL;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import org.reactivestreams.Publisher;
+
+public class FirebaseFunctionsStreamHandler implements StreamHandler {
+
+  private final FirebaseFunctions firebaseFunctions;
+
+  private StreamResponseSubscriber subscriber;
+
+  public FirebaseFunctionsStreamHandler(FirebaseFunctions functions) {
+    this.firebaseFunctions = functions;
+  }
+
+  @Override
+  public void onListen(Object arguments, EventChannel.EventSink events) {
+    @SuppressWarnings("unchecked")
+    Map<String, Object> argumentsMap = (Map<String, Object>) arguments;
+    httpsStreamCall(argumentsMap, events);
+  }
+
+  @Override
+  public void onCancel(Object arguments) {
+    subscriber.cancel();
+  }
+
+  private void httpsStreamCall(Map<String, Object> arguments, EventChannel.EventSink events) {
+    try {
+
+      String functionName = (String) arguments.get("functionName");
+      String functionUri = (String) arguments.get("functionUri");
+      String origin = (String) arguments.get("origin");
+      Integer timeout = (Integer) arguments.get("timeout");
+      Object parameters = arguments.get("parameters");
+      boolean limitedUseAppCheckToken =
+          (boolean) Objects.requireNonNull(arguments.get("limitedUseAppCheckToken"));
+
+      if (origin != null) {
+        Uri originUri = Uri.parse(origin);
+        firebaseFunctions.useEmulator(originUri.getHost(), originUri.getPort());
+      }
+
+      HttpsCallableReference httpsCallableReference;
+      HttpsCallableOptions options =
+          new HttpsCallableOptions.Builder()
+              .setLimitedUseAppCheckTokens(limitedUseAppCheckToken)
+              .build();
+
+      Publisher<StreamResponse> publisher;
+      if (functionName != null) {
+        httpsCallableReference = firebaseFunctions.getHttpsCallable(functionName, options);
+        publisher = httpsCallableReference.stream(parameters);
+      } else if (functionUri != null) {
+        httpsCallableReference =
+            firebaseFunctions.getHttpsCallableFromUrl(new URL(functionUri), options);
+        publisher = httpsCallableReference.stream();
+      } else {
+        throw new IllegalArgumentException("Either functionName or functionUri must be set");
+      }
+
+      if (timeout != null) {
+        httpsCallableReference.setTimeout(timeout.longValue(), TimeUnit.MILLISECONDS);
+      }
+      subscriber = new StreamResponseSubscriber(events);
+      publisher.subscribe(subscriber);
+    } catch (Exception e) {
+      events.error("firebase_functions", e.getMessage(), null);
+    }
+  }
+}

packages/cloud_functions/cloud_functions/android/src/main/java/io/flutter/plugins/firebase/functions/FlutterFirebaseFunctionsPlugin.java

@@ -17,6 +17,7 @@
 import com.google.firebase.functions.HttpsCallableReference;
 import com.google.firebase.functions.HttpsCallableResult;
 import io.flutter.embedding.engine.plugins.FlutterPlugin;
+import io.flutter.plugin.common.EventChannel;
 import io.flutter.plugin.common.MethodCall;
 import io.flutter.plugin.common.MethodChannel;
 import io.flutter.plugin.common.MethodChannel.MethodCallHandler;
@@ -35,6 +36,7 @@ public class FlutterFirebaseFunctionsPlugin
 
   private static final String METHOD_CHANNEL_NAME = "plugins.flutter.io/firebase_functions";
   private MethodChannel channel;
+  private FlutterPluginBinding pluginBinding;
 
   /**
    * Default Constructor.
@@ -45,6 +47,7 @@ public FlutterFirebaseFunctionsPlugin() {}
 
   @Override
   public void onAttachedToEngine(@NonNull FlutterPluginBinding binding) {
+    pluginBinding = binding;
     channel = new MethodChannel(binding.getBinaryMessenger(), METHOD_CHANNEL_NAME);
     channel.setMethodCallHandler(this);
   }
@@ -55,6 +58,16 @@ public void onDetachedFromEngine(@NonNull FlutterPluginBinding binding) {
     channel = null;
   }
 
+  private void registerEventChannel(Map<String, Object> arguments) {
+    final String eventId = (String) Objects.requireNonNull(arguments.get("eventChannelId"));
+    final String eventChannelName = METHOD_CHANNEL_NAME + "/" + eventId;
+    final EventChannel eventChannel =
+        new EventChannel(pluginBinding.getBinaryMessenger(), eventChannelName);
+    FirebaseFunctions functions = getFunctions(arguments);
+    FirebaseFunctionsStreamHandler streamHandler = new FirebaseFunctionsStreamHandler(functions);
+    eventChannel.setStreamHandler(streamHandler);
+  }
+
   private FirebaseFunctions getFunctions(Map<String, Object> arguments) {
     String appName = (String) Objects.requireNonNull(arguments.get("appName"));
     String region = (String) Objects.requireNonNull(arguments.get("region"));
@@ -116,24 +129,26 @@ private Task<Object> httpsFunctionCall(Map<String, Object> arguments) {
 
   @Override
   public void onMethodCall(MethodCall call, @NonNull final Result result) {
-    if (!call.method.equals("FirebaseFunctions#call")) {
+    if (call.method.equals("FirebaseFunctions#registerEventChannel")) {
+      registerEventChannel(call.arguments());
+      result.success(null);
+    } else if (call.method.equals("FirebaseFunctions#call")) {
+      httpsFunctionCall(call.arguments())
+          .addOnCompleteListener(
+              task -> {
+                if (task.isSuccessful()) {
+                  result.success(task.getResult());
+                } else {
+                  Exception exception = task.getException();
+                  result.error(
+                      "firebase_functions",
+                      exception != null ? exception.getMessage() : null,
+                      getExceptionDetails(exception));
+                }
+              });
+    } else {
       result.notImplemented();
-      return;
     }
-
-    httpsFunctionCall(call.arguments())
-        .addOnCompleteListener(
-            task -> {
-              if (task.isSuccessful()) {
-                result.success(task.getResult());
-              } else {
-                Exception exception = task.getException();
-                result.error(
-                    "firebase_functions",
-                    exception != null ? exception.getMessage() : null,
-                    getExceptionDetails(exception));
-              }
-            });
   }
 
   private Map<String, Object> getExceptionDetails(@Nullable Exception exception) {