以下是我们在 I/O 大会上宣布的所有内容，从新的 Firebase Studio 功能到集成 AI 的更多方式，内容非常丰富。阅读博客。

หน้านี้ได้รับการแปลโดย Cloud Translation API

เรียกใช้ฟังก์ชันจากแอปของคุณ

Cloud Functions for Firebase SDK ของไคลเอ็นต์ช่วยให้คุณเรียกใช้ฟังก์ชันได้โดยตรงจาก แอป Firebase หากต้องการเรียกใช้ฟังก์ชันจากแอปด้วยวิธีนี้ ให้เขียนและติดตั้งใช้งาน ฟังก์ชันที่เรียกใช้ได้ผ่าน HTTP ใน Cloud Functions แล้ว เพิ่มตรรกะของไคลเอ็นต์เพื่อเรียกใช้ฟังก์ชันจากแอป

โปรดทราบว่าฟังก์ชันที่เรียกใช้ HTTP ได้จะคล้ายกับฟังก์ชัน HTTP แต่ไม่เหมือนกัน หากต้องการใช้ฟังก์ชันที่เรียกใช้ได้ผ่าน HTTP คุณต้องใช้ SDK ของไคลเอ็นต์สำหรับแพลตฟอร์มของคุณร่วมกับ API แบ็กเอนด์ (หรือใช้โปรโตคอล) ฟังก์ชันที่เรียกใช้ได้มีความแตกต่างที่สำคัญจากฟังก์ชัน HTTP ดังนี้

เมื่อมีให้ใช้งาน ระบบจะรวมโทเค็น Firebase Authentication, FCM และ App Check ไว้ในคำขอโดยอัตโนมัติ
ทริกเกอร์จะยกเลิกการซีเรียลไลซ์ส่วนเนื้อหาของคำขอและตรวจสอบโทเค็นการให้สิทธิ์โดยอัตโนมัติ

Firebase SDK สำหรับ Cloud Functions รุ่นที่ 2 ขึ้นไปจะทำงานร่วมกับ Firebase Client SDK เวอร์ชันขั้นต่ำต่อไปนี้เพื่อรองรับฟังก์ชันที่เรียกใช้ได้ผ่าน HTTPS

Firebase SDK สำหรับแพลตฟอร์ม Apple 11.15.0
Firebase SDK สำหรับ Android 21.2.1
Firebase Modular Web SDK v. 9.7.0

หากต้องการเพิ่มฟังก์ชันที่คล้ายกันลงในแอปที่สร้างบนแพลตฟอร์มที่ไม่รองรับ โปรดดูข้อกำหนดโปรโตคอลสำหรับ https.onCall ส่วนที่เหลือของคู่มือนี้จะให้ วิธีการเขียน การติดตั้งใช้งาน และการเรียกใช้ ฟังก์ชันที่เรียกใช้ได้ผ่าน HTTP สำหรับแพลตฟอร์ม Apple, Android, เว็บ, C++ และ Unity

เขียนและติดตั้งใช้งานฟังก์ชันที่เรียกใช้ได้

ตัวอย่างโค้ดในส่วนนี้อิงตาม ตัวอย่างการเริ่มต้นใช้งานฉบับย่อ ที่สมบูรณ์ซึ่งแสดงวิธีส่งคำขอไปยังฟังก์ชันฝั่งเซิร์ฟเวอร์และรับ การตอบกลับโดยใช้ Client SDK อย่างใดอย่างหนึ่ง หากต้องการเริ่มต้นใช้งาน ให้นำเข้าโมดูลที่จำเป็น

Node.js

// Dependencies for callable functions.
const {onCall, HttpsError} = require("firebase-functions/v2/https");
const {logger} = require("firebase-functions/v2");

// Dependencies for the addMessage function.
const {getDatabase} = require("firebase-admin/database");
const sanitizer = require("./sanitizer");index.js

Python

# Dependencies for callable functions.
from firebase_functions import https_fn, options

# Dependencies for writing to Realtime Database.
from firebase_admin import db, initialize_appmain.py

ใช้ตัวแฮนเดิลคำขอสำหรับแพลตฟอร์มของคุณ (functions.https.onCall) หรือ on_call) เพื่อสร้างฟังก์ชันที่เรียกใช้ได้ผ่าน HTTPS เมธอดนี้ ใช้พารามิเตอร์คำขอ

Node.js

// Saves a message to the Firebase Realtime Database but sanitizes the
// text by removing swearwords.
exports.addmessage = onCall((request) => {
  // ...
});index.js

Python

@https_fn.on_call()
def addmessage(req: https_fn.CallableRequest) -> Any:
    """Saves a message to the Firebase Realtime Database but sanitizes the text
    by removing swear words."""main.py

พารามิเตอร์ request มีข้อมูลที่ส่งจากแอปไคลเอ็นต์ รวมถึงบริบทเพิ่มเติม เช่น สถานะการตรวจสอบสิทธิ์ สำหรับฟังก์ชันที่เรียกใช้ได้ซึ่งบันทึกข้อความไปยัง Realtime Database เช่น data อาจมีข้อความพร้อมข้อมูลการให้สิทธิ์ ใน auth

Node.js

// Message text passed from the client.
const text = request.data.text;
// Authentication / user information is automatically added to the request.
const uid = request.auth.uid;
const name = request.auth.token.name || null;
const picture = request.auth.token.picture || null;
const email = request.auth.token.email || null;index.js

Python

# Message text passed from the client.
text = req.data["text"]main.py
# Authentication / user information is automatically added to the request.
uid = req.auth.uid
name = req.auth.token.get("name", "")
picture = req.auth.token.get("picture", "")
email = req.auth.token.get("email", "")main.py

ระยะห่างระหว่างตำแหน่งของฟังก์ชันที่เรียกใช้ได้กับตำแหน่งของไคลเอ็นต์ที่เรียกใช้จะทำให้เกิดเวลาในการตอบสนองของเครือข่าย หากต้องการเพิ่มประสิทธิภาพ ให้พิจารณาระบุตำแหน่งฟังก์ชันในกรณีที่เกี่ยวข้อง และตรวจสอบว่าตำแหน่งของฟังก์ชันที่เรียกใช้ได้สอดคล้องกับตำแหน่งที่ตั้งค่าไว้เมื่อเริ่มต้น SDK ในฝั่งไคลเอ็นต์

คุณแนบApp Checkการรับรองเพื่อช่วยปกป้องทรัพยากรแบ็กเอนด์จากการละเมิด เช่น การฉ้อโกงผ่านการเรียกเก็บเงินหรือฟิชชิง ได้ (ไม่บังคับ) ดูเปิดใช้การบังคับใช้ App Check สำหรับ Cloud Functions

ส่งผลการค้นหากลับ

หากต้องการส่งข้อมูลกลับไปยังไคลเอ็นต์ ให้ส่งข้อมูลที่เข้ารหัส JSON ได้ เช่น หากต้องการแสดงผลลัพธ์ของการดำเนินการบวก ให้ทำดังนี้

Node.js

// returning result.
return {
  firstNumber: firstNumber,
  secondNumber: secondNumber,
  operator: "+",
  operationResult: firstNumber + secondNumber,
};index.js

Python

return {
    "firstNumber": first_number,
    "secondNumber": second_number,
    "operator": "+",
    "operationResult": first_number + second_number
}main.py

ระบบจะส่งคืนข้อความที่ผ่านการล้างข้อมูลจากตัวอย่างข้อความไปยังทั้งไคลเอ็นต์และ Realtime Database ใน Node.js คุณทำได้ แบบไม่พร้อมกันโดยใช้ JavaScript Promise ดังนี้

Node.js

// Saving the new message to the Realtime Database.
const sanitizedMessage = sanitizer.sanitizeText(text); // Sanitize message.

return getDatabase().ref("/messages").push({
  text: sanitizedMessage,
  author: {uid, name, picture, email},
}).then(() => {
  logger.info("New Message written");
  // Returning the sanitized message to the client.
  return {text: sanitizedMessage};
})index.js

Python

# Saving the new message to the Realtime Database.
sanitized_message = sanitize_text(text)  # Sanitize message.
db.reference("/messages").push({  # type: ignore
    "text": sanitized_message,
    "author": {
        "uid": uid,
        "name": name,
        "picture": picture,
        "email": email
    }
})
print("New message written")

# Returning the sanitized message to the client.
return {"text": sanitized_message}main.py

ส่งและรับผลการสตรีม

ฟังก์ชันที่เรียกใช้ได้มีกลไกในการจัดการผลลัพธ์การสตรีม หากมี กรณีการใช้งานที่ต้องมีการสตรีม คุณสามารถกำหนดค่าการสตรีมในคำขอที่เรียกใช้ได้ แล้วใช้วิธีที่เหมาะสมจาก SDK ของไคลเอ็นต์เพื่อเรียกใช้ฟังก์ชัน

ส่งผลการสตรีม

หากต้องการสตรีมผลลัพธ์ที่สร้างขึ้นเมื่อเวลาผ่านไปอย่างมีประสิทธิภาพ เช่น จากคำขอ API แยกกันหลายรายการหรือจาก Generative AI API ให้ตรวจสอบพร็อพเพอร์ตี้ acceptsStreaming ในคำขอที่เรียกใช้ได้ เมื่อตั้งค่าพร็อพเพอร์ตี้นี้เป็น true คุณจะสตรีมผลลัพธ์กลับไปยังไคลเอ็นต์ได้ด้วย response.sendChunk()

ตัวอย่างเช่น หากแอปต้องการดึงข้อมูลพยากรณ์อากาศสำหรับหลายสถานที่ ฟังก์ชันที่เรียกใช้ได้จะส่งการพยากรณ์ของแต่ละสถานที่แยกกัน ไปยังไคลเอ็นต์ที่ขอการตอบกลับแบบสตรีม แทนที่จะให้ไคลเอ็นต์รอ จนกว่าคำขอพยากรณ์ทั้งหมดจะได้รับการแก้ไข

exports.getForecast = onCall(async (request, response) => {
  if (request.data?.locations?.length < 1) {
    throw new HttpsError("invalid-argument", "Missing locations to forecast");
  }

  // fetch forecast data for all requested locations
  const allRequests = request.data.locations.map(
      async ({latitude, longitude}) => {
        const forecast = await weatherForecastApi(latitude, longitude);
        const result = {latitude, longitude, forecast};

        // clients that support streaming will have each
        // forecast streamed to them as they complete
        if (request.acceptsStreaming) {
          response.sendChunk(result);
        }

        return result;
      },
  );

  // Return the full set of data to all clients
  return Promise.all(allRequests);
});index.js

โปรดทราบว่าวิธีที่ response.sendChunk() ทำงานจะขึ้นอยู่กับรายละเอียดบางอย่างของคำขอของลูกค้า ดังนี้

หากไคลเอ็นต์ขอการตอบกลับแบบสตรีม response.sendChunk(data) จะส่งข้อมูลทันที
หากไคลเอ็นต์ไม่ขอการตอบกลับแบบสตรีม response.sendChunk() จะไม่ดำเนินการใดๆ สำหรับการเรียกนั้น ระบบจะส่งการตอบกลับทั้งหมดเมื่อข้อมูลทั้งหมดพร้อม

หากต้องการพิจารณาว่าไคลเอ็นต์ขอการตอบกลับแบบสตรีมหรือไม่ ให้ตรวจสอบพร็อพเพอร์ตี้ request.acceptsStreaming เช่น หาก request.acceptsStreaming เป็นเท็จ คุณอาจเลือกที่จะข้ามงานที่ใช้ทรัพยากรมากซึ่งเกี่ยวข้องกับการเตรียมหรือส่งก้อนข้อมูลแต่ละก้อนโดยเฉพาะ เนื่องจากไคลเอ็นต์ไม่ได้คาดหวัง การนำส่งแบบเพิ่ม

รับผลการสตรีม

ในสถานการณ์ทั่วไป ไคลเอ็นต์จะขอสตรีมด้วยเมธอด .stream จากนั้นจะวนซ้ำผ่านผลลัพธ์

Swift

func listenToWeatherForecast() async throws {
    isLoading = true
    defer { isLoading = false }

    Functions
      .functions(region: "us-central1")
    let getForecast: Callable<WeatherRequest, StreamResponse<WeatherResponse, [WeatherResponse]>> = Functions.functions().httpsCallable("getForecast")

    let request = WeatherRequest(locations: locations)
    let stream = try getForecast.stream(request)

    for try await response in stream {
      switch response {
      case .message(let singleResponse):
        weatherData["\(singleResponse.latitude),\(singleResponse.longitude)"] = singleResponse
      case .result(let arrayOfResponses):
        for response in arrayOfResponses {
          weatherData["\(response.latitude),\(response.longitude)"] = response
        }
        print("Stream ended.")
        return
      }
    }
  }

Web

// Get the callable by passing an initialized functions SDK.
const getForecast = httpsCallable(functions, "getForecast");

// Call the function with the `.stream()` method to start streaming.
const { stream, data } = await getForecast.stream({
  locations: favoriteLocations,
});

// The `stream` async iterable returned by `.stream()`
// will yield a new value every time the callable
// function calls `sendChunk()`.
for await (const forecastDataChunk of stream) {
  // update the UI every time a new chunk is received
  // from the callable function
  updateUi(forecastDataChunk);
}

// The `data` promise resolves when the callable
// function completes.
const allWeatherForecasts = await data;
finalizeUi(allWeatherForecasts);index.html

วนซ้ำผ่าน stream async iterable ตามที่แสดง data การรอสัญญาจะบ่งบอกให้ไคลเอ็นต์ทราบว่าคำขอเสร็จสมบูรณ์แล้ว

Kotlin

// Get the callable by passing an initialized functions SDK.
val getForecast = functions.getHttpsCallable("getForecast");

// Call the function with the `.stream()` method and convert it to a flow
getForecast.stream(
  mapOf("locations" to favoriteLocations)
).asFlow().collect { response ->
  when (response) {
    is StreamResponse.Message -> {
      // The flow will emit a [StreamResponse.Message] value every time the
      // callable function calls `sendChunk()`.
      val forecastDataChunk = response.message.data as Map<String, Any>
      // Update the UI every time a new chunk is received
      // from the callable function
      updateUI(
        forecastDataChunk["latitude"] as Double,
        forecastDataChunk["longitude"] as Double,
        forecastDataChunk["forecast"] as Double,
      )
    }
    is StreamResponse.Result -> {
      // The flow will emit a [StreamResponse.Result] value when the
      // callable function completes.
      val allWeatherForecasts = response.result.data as List<Map<String, Any>>
      finalizeUI(allWeatherForecasts)
    }
  }
}MainActivity.kt

หากต้องการใช้ฟังก์ชันส่วนขยาย asFlow() ให้เพิ่มไลบรารี org.jetbrains.kotlinx:kotlinx-coroutines-reactive เป็น การอ้างอิงในไฟล์ build.gradle(.kts) ของแอป

Java

// Get the callable by passing an initialized functions SDK.
HttpsCallableReference getForecast = mFunctions.getHttpsCallable("getForecast");
getForecast.stream(
  new HashMap<String, Object>() {{
    put("locations", favoriteLocations);
  }}
).subscribe(new Subscriber<StreamResponse>() {
  @Override
  public void onSubscribe(Subscription subscription) {
    subscription.request(Long.MAX_VALUE);
  }

  @Override
  public void onNext(StreamResponse streamResponse) {
    if (streamResponse instanceof StreamResponse.Message) {
      // The flow will emit a [StreamResponse.Message] value every time the
      // callable function calls `sendChunk()`.
      StreamResponse.Message response = (StreamResponse.Message) streamResponse;
      Map<String, Object> forecastDataChunk =
        (Map<String, Object>) response.getMessage().getData();
      // Update the UI every time a new chunk is received
      // from the callable function
      updateUI(
        (double) forecastDataChunk.get("latitude"),
        (double) forecastDataChunk.get("longitude"),
        (double) forecastDataChunk.get("forecast")
      );
    } else if(streamResponse instanceof StreamResponse.Result) {
      // The flow will emit a [StreamResponse.Result] value when the
      // callable function completes.
      StreamResponse.Result response = (StreamResponse.Result) streamResponse;
      List<Map<String, Object>> allWeatherForecasts =
        (List<Map<String, Object>>) response.getResult().getData();
      finalizeUI();
    }
  }

  @Override
  public void onError(Throwable throwable) {
    // an error occurred in the function
  }

  @Override
  public void onComplete() {

  }
});MainActivity.java

กำหนดค่า CORS (การแชร์ทรัพยากรแบบข้ามต้นทาง)

ใช้ตัวเลือก cors เพื่อควบคุมว่าต้นทางใดบ้างที่เข้าถึงฟังก์ชันได้

โดยค่าเริ่มต้น ฟังก์ชันที่เรียกใช้ได้จะมี CORS ที่กำหนดค่าไว้เพื่ออนุญาตคำขอจากต้นทางทั้งหมด หากต้องการอนุญาตคำขอข้ามต้นทางบางรายการ แต่ไม่อนุญาตทั้งหมด ให้ส่งรายการ โดเมนที่เฉพาะเจาะจงหรือนิพจน์ทั่วไปที่ควรได้รับอนุญาต เช่น

Node.js

const { onCall } = require("firebase-functions/v2/https");

exports.getGreeting = onCall(
  { cors: [/firebase\.com$/, "https://flutter.com"] },
  (request) => {
    return "Hello, world!";
  }
);

หากต้องการห้ามคำขอข้ามต้นทาง ให้ตั้งค่านโยบาย cors เป็น false

จัดการข้อผิดพลาด

หากต้องการให้ไคลเอ็นต์ได้รับรายละเอียดข้อผิดพลาดที่เป็นประโยชน์ ให้ส่งข้อผิดพลาดจากฟังก์ชันที่เรียกใช้ได้ โดยการส่งข้อยกเว้น (หรือสำหรับ Node.js ให้ส่งคืน Promise ที่ถูกปฏิเสธด้วย) อินสแตนซ์ของ functions.https.HttpsError หรือ https_fn.HttpsError ข้อผิดพลาดมีแอตทริบิวต์ code ซึ่งอาจเป็นค่าใดค่าหนึ่งที่แสดงในรหัสสถานะของ gRPC ข้อผิดพลาดยังมีสตริง message ซึ่งค่าเริ่มต้น จะเป็นสตริงว่าง นอกจากนี้ ยังมีdetailsฟิลด์ที่ไม่บังคับซึ่งมีค่า โดยพลการได้ด้วย หากฟังก์ชันแสดงข้อผิดพลาดอื่นที่ไม่ใช่ข้อผิดพลาด HTTPS ไคลเอ็นต์จะได้รับข้อผิดพลาดพร้อมข้อความ INTERNAL และรหัส internal แทน

ตัวอย่างเช่น ฟังก์ชันอาจส่งข้อผิดพลาดในการตรวจสอบข้อมูลและการตรวจสอบสิทธิ์ พร้อมข้อความแสดงข้อผิดพลาดเพื่อส่งกลับไปยังไคลเอ็นต์ที่เรียกใช้

Node.js

// Checking attribute.
if (!(typeof text === "string") || text.length === 0) {
  // Throwing an HttpsError so that the client gets the error details.
  throw new HttpsError("invalid-argument", "The function must be called " +
          "with one arguments \"text\" containing the message text to add.");
}
// Checking that the user is authenticated.
if (!request.auth) {
  // Throwing an HttpsError so that the client gets the error details.
  throw new HttpsError("failed-precondition", "The function must be " +
          "called while authenticated.");
}index.js

Python

# Checking attribute.
if not isinstance(text, str) or len(text) < 1:
    # Throwing an HttpsError so that the client gets the error details.
    raise https_fn.HttpsError(code=https_fn.FunctionsErrorCode.INVALID_ARGUMENT,
                              message=('The function must be called with one argument, "text",'
                                       " containing the message text to add."))

# Checking that the user is authenticated.
if req.auth is None:
    # Throwing an HttpsError so that the client gets the error details.
    raise https_fn.HttpsError(code=https_fn.FunctionsErrorCode.FAILED_PRECONDITION,
                              message="The function must be called while authenticated.")main.py

ทําให้ฟังก์ชันที่เรียกใช้ได้ใช้งานได้

หลังจากบันทึกฟังก์ชันที่เรียกใช้ได้ที่เสร็จสมบูรณ์แล้วภายใน index.js ระบบจะ นําไปใช้งานพร้อมกับฟังก์ชันอื่นๆ ทั้งหมดเมื่อคุณเรียกใช้ firebase deploy หากต้องการปรับใช้เฉพาะฟังก์ชันที่เรียกใช้ได้ ให้ใช้--onlyอาร์กิวเมนต์ตามที่แสดงเพื่อปรับใช้บางส่วน

firebase deploy --only functions:addMessage

หากพบข้อผิดพลาดเกี่ยวกับสิทธิ์เมื่อติดตั้งใช้งานฟังก์ชัน โปรดตรวจสอบว่าได้กำหนดบทบาท IAM ที่เหมาะสมให้กับผู้ใช้ที่เรียกใช้คำสั่งการติดตั้งใช้งานแล้ว

ตั้งค่าสภาพแวดล้อมในการพัฒนาไคลเอ็นต์

ตรวจสอบว่าคุณมีข้อกำหนดเบื้องต้นทั้งหมด จากนั้นเพิ่มการอ้างอิงและ ไลบรารีไคลเอ็นต์ที่จำเป็นลงในแอป

iOS+

ทำตามวิธีการเพื่อเพิ่ม Firebase ลงในแอป Apple

ใช้ Swift Package Manager เพื่อติดตั้งและจัดการทรัพยากร Dependency ของ Firebase

เปิดโปรเจ็กต์แอปใน Xcode แล้วไปที่File > Add Packages
เมื่อได้รับข้อความแจ้ง ให้เพิ่มที่เก็บ SDK ของแพลตฟอร์ม Apple ของ Firebase ดังนี้

  https://github.com/firebase/firebase-ios-sdk.git

เลือกCloud Functions คลัง
เพิ่มแฟล็ก -ObjC ลงในส่วนแฟล็ก Linker อื่นๆ ของการตั้งค่าบิลด์ของเป้าหมาย
เมื่อเสร็จแล้ว Xcode จะเริ่มจับคู่ข้อมูลและดาวน์โหลดทรัพยากร Dependency ในเบื้องหลังโดยอัตโนมัติ

Web

ทำตามวิธีการเพื่อเพิ่ม Firebase ลงในเว็บแอป อย่าลืมเรียกใช้คำสั่งต่อไปนี้จากเทอร์มินัล
```
npm install firebase@11.10.0 --save
```

ต้องกำหนดทั้ง Firebase Core และ Cloud Functions ด้วยตนเอง

 import { initializeApp } from 'firebase/app';
 import { getFunctions } from 'firebase/functions';

 const app = initializeApp({
     projectId: '### CLOUD FUNCTIONS PROJECT ID ###',
     apiKey: '### FIREBASE API KEY ###',
     authDomain: '### FIREBASE AUTH DOMAIN ###',
   });
 const functions = getFunctions(app);

Android

ทําตามวิธีการเพื่อเพิ่ม Firebase ลงในแอป Android
ในไฟล์ Gradle ของโมดูล (ระดับแอป) (โดยปกติคือ <project>/<app-module>/build.gradle.kts หรือ <project>/<app-module>/build.gradle) ให้เพิ่มทรัพยากร Dependency สำหรับคลัง Cloud Functions สำหรับ Android เราขอแนะนำให้ใช้ Firebase Android BoM เพื่อควบคุมการควบคุมเวอร์ชันของไลบรารี
```
dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.16.0"))

    // Add the dependency for the Cloud Functions library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-functions")
}
```
การใช้ Firebase Android BoM จะทำให้แอปใช้ไลบรารี Firebase Android เวอร์ชันที่เข้ากันได้อยู่เสมอ
(ทางเลือก) เพิ่มการอ้างอิงไลบรารี Firebase โดยไม่ใช้ BoM

หากเลือกไม่ใช้ Firebase BoM คุณต้องระบุเวอร์ชันของไลบรารี Firebase แต่ละรายการ ในบรรทัดการอ้างอิง

โปรดทราบว่าหากคุณใช้ไลบรารี Firebase หลายรายการในแอป เราขอแนะนำเป็นอย่างยิ่ง ให้ใช้ BoM เพื่อจัดการเวอร์ชันของไลบรารี ซึ่งจะช่วยให้มั่นใจได้ว่าทุกเวอร์ชันจะ เข้ากันได้
```
dependencies {
    // Add the dependency for the Cloud Functions library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-functions:21.2.1")
}
```
หากกำลังมองหาโมดูลไลบรารีเฉพาะของ Kotlin ตั้งแต่เดือน ตุลาคม 2023 (Firebase BoM 32.5.0) เป็นต้นไป นักพัฒนาแอปทั้ง Kotlin และ Java จะ ขึ้นอยู่กับโมดูลไลบรารีหลักได้ (ดูรายละเอียดได้ที่ คำถามที่พบบ่อยเกี่ยวกับโครงการนี้)

เริ่มต้น SDK ของไคลเอ็นต์

เริ่มต้นอินสแตนซ์ของ Cloud Functions

Swift

lazy var functions = Functions.functions()CloudAddCell.swift

Objective-C

@property(strong, nonatomic) FIRFunctions *functions;
// ...
self.functions = [FIRFunctions functions];CloudAddCell.m

Web

const app = initializeApp({
  projectId: '### CLOUD FUNCTIONS PROJECT ID ###',
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
});
const functions = getFunctions(app);

Kotlin

private lateinit var functions: FirebaseFunctions
// ...
functions = Firebase.functionsMainActivity.kt

Java

private FirebaseFunctions mFunctions;
// ...
mFunctions = FirebaseFunctions.getInstance();MainActivity.java