使用 Gemini API 生成文本

 import FirebaseAILogic // Initialize the Gemini Developer API backend service let ai = FirebaseAI.firebaseAI(backend: .googleAI()) // Create a `GenerativeModel` instance with a model that supports your use case let model = ai.generativeModel(modelName: "gemini-2.5-flash") // Provide a prompt that contains text let prompt = "Write a story about a magic backpack." // To stream generated text output, call generateContentStream with the text input let contentStream = try model.generateContentStream(prompt) for try await chunk in contentStream {  if let text = chunk.text {  print(text)  } } 

 // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case val model = Firebase.ai(backend = GenerativeBackend.googleAI())  .generativeModel("gemini-2.5-flash") // Provide a prompt that includes only text val prompt = "Write a story about a magic backpack." // To stream generated text output, call generateContentStream and pass in the prompt var response = "" model.generateContentStream(prompt).collect { chunk ->  print(chunk.text)  response += chunk.text } 

 // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())  .generativeModel("gemini-2.5-flash"); // Use the GenerativeModelFutures Java compatibility layer which offers // support for ListenableFuture and Publisher APIs GenerativeModelFutures model = GenerativeModelFutures.from(ai); // Provide a prompt that contains text Content prompt = new Content.Builder()  .addText("Write a story about a magic backpack.")  .build(); // To stream generated text output, call generateContentStream with the text input Publisher<GenerateContentResponse> streamingResponse =  model.generateContentStream(prompt); // Subscribe to partial results from the response final String[] fullResponse = {""}; streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {  @Override  public void onNext(GenerateContentResponse generateContentResponse) {  String chunk = generateContentResponse.getText();  fullResponse[0] += chunk;  }  @Override  public void onComplete() {  System.out.println(fullResponse[0]);  }  @Override  public void onError(Throwable t) {  t.printStackTrace();  }  @Override  public void onSubscribe(Subscription s) { } }); 

 import { initializeApp } from "firebase/app"; import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai"; // TODO(developer) Replace the following with your app's Firebase configuration // See: https://firebase.google.com/docs/web/learn-more#config-object const firebaseConfig = {  // ... }; // Initialize FirebaseApp const firebaseApp = initializeApp(firebaseConfig); // Initialize the Gemini Developer API backend service const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() }); // Create a `GenerativeModel` instance with a model that supports your use case const model = getGenerativeModel(ai, { model: "gemini-2.5-flash" }); // Wrap in an async function so you can use await async function run() {  // Provide a prompt that contains text  const prompt = "Write a story about a magic backpack."  // To stream generated text output, call generateContentStream with the text input  const result = await model.generateContentStream(prompt);  for await (const chunk of result.stream) {  const chunkText = chunk.text();  console.log(chunkText);  }  console.log('aggregated response: ', await result.response); } run(); 

 import 'package:firebase_ai/firebase_ai.dart'; import 'package:firebase_core/firebase_core.dart'; import 'firebase_options.dart'; // Initialize FirebaseApp await Firebase.initializeApp(  options: DefaultFirebaseOptions.currentPlatform, ); // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case final model =  FirebaseAI.googleAI().generativeModel(model: 'gemini-2.5-flash'); // Provide a prompt that contains text final prompt = [Content.text('Write a story about a magic backpack.')]; // To stream generated text output, call generateContentStream with the text input final response = model.generateContentStream(prompt); await for (final chunk in response) {  print(chunk.text); } 

 using Firebase; using Firebase.AI; // Initialize the Gemini Developer API backend service var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()); // Create a `GenerativeModel` instance with a model that supports your use case var model = ai.GetGenerativeModel(modelName: "gemini-2.5-flash"); // Provide a prompt that contains text var prompt = "Write a story about a magic backpack."; // To stream generated text output, call GenerateContentStreamAsync with the text input var responseStream = model.GenerateContentStreamAsync(prompt); await foreach (var response in responseStream) {  if (!string.IsNullOrWhiteSpace(response.Text)) {  UnityEngine.Debug.Log(response.Text);  } } 

 import FirebaseAILogic // Initialize the Gemini Developer API backend service let ai = FirebaseAI.firebaseAI(backend: .googleAI()) // Create a `GenerativeModel` instance with a model that supports your use case let model = ai.generativeModel(modelName: "gemini-2.5-flash") // Provide the video as `Data` with the appropriate MIME type let video = InlineDataPart(data: try Data(contentsOf: videoURL), mimeType: "video/mp4") // Provide a text prompt to include with the video let prompt = "What is in the video?" // To stream generated text output, call generateContentStream with the text and video let contentStream = try model.generateContentStream(video, prompt) for try await chunk in contentStream {  if let text = chunk.text {  print(text)  } } 

 // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case val model = Firebase.ai(backend = GenerativeBackend.googleAI())  .generativeModel("gemini-2.5-flash") val contentResolver = applicationContext.contentResolver contentResolver.openInputStream(videoUri).use { stream ->  stream?.let {  val bytes = stream.readBytes()  // Provide a prompt that includes the video specified above and text  val prompt = content {  inlineData(bytes, "video/mp4")  text("What is in the video?")  }  // To stream generated text output, call generateContentStream with the prompt  var fullResponse = ""  model.generateContentStream(prompt).collect { chunk ->  Log.d(TAG, chunk.text ?: "")  fullResponse += chunk.text  }  } } 

 // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())  .generativeModel("gemini-2.5-flash"); // Use the GenerativeModelFutures Java compatibility layer which offers // support for ListenableFuture and Publisher APIs GenerativeModelFutures model = GenerativeModelFutures.from(ai); ContentResolver resolver = getApplicationContext().getContentResolver(); try (InputStream stream = resolver.openInputStream(videoUri)) {  File videoFile = new File(new URI(videoUri.toString()));  int videoSize = (int) videoFile.length();  byte[] videoBytes = new byte[videoSize];  if (stream != null) {  stream.read(videoBytes, 0, videoBytes.length);  stream.close();  // Provide a prompt that includes the video specified above and text  Content prompt = new Content.Builder()  .addInlineData(videoBytes, "video/mp4")  .addText("What is in the video?")  .build();  // To stream generated text output, call generateContentStream with the prompt  Publisher<GenerateContentResponse> streamingResponse =  model.generateContentStream(prompt);  final String[] fullResponse = {""};  streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {  @Override  public void onNext(GenerateContentResponse generateContentResponse) {  String chunk = generateContentResponse.getText();  fullResponse[0] += chunk;  }  @Override  public void onComplete() {  System.out.println(fullResponse[0]);  }  @Override  public void onError(Throwable t) {  t.printStackTrace();  }  @Override  public void onSubscribe(Subscription s) {  }  });  } } catch (IOException e) {  e.printStackTrace(); } catch (URISyntaxException e) {  e.printStackTrace(); } 

 import { initializeApp } from "firebase/app"; import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai"; // TODO(developer) Replace the following with your app's Firebase configuration // See: https://firebase.google.com/docs/web/learn-more#config-object const firebaseConfig = {  // ... }; // Initialize FirebaseApp const firebaseApp = initializeApp(firebaseConfig); // Initialize the Gemini Developer API backend service const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() }); // Create a `GenerativeModel` instance with a model that supports your use case const model = getGenerativeModel(ai, { model: "gemini-2.5-flash" }); // Converts a File object to a Part object. async function fileToGenerativePart(file) {  const base64EncodedDataPromise = new Promise((resolve) => {  const reader = new FileReader();  reader.onloadend = () => resolve(reader.result.split(',')[1]);  reader.readAsDataURL(file);  });  return {  inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },  }; } async function run() {  // Provide a text prompt to include with the video  const prompt = "What do you see?";  const fileInputEl = document.querySelector("input[type=file]");  const videoPart = await fileToGenerativePart(fileInputEl.files[0]);  // To stream generated text output, call generateContentStream with the text and video  const result = await model.generateContentStream([prompt, videoPart]);  for await (const chunk of result.stream) {  const chunkText = chunk.text();  console.log(chunkText);  } } run(); 

 import 'package:firebase_ai/firebase_ai.dart'; import 'package:firebase_core/firebase_core.dart'; import 'firebase_options.dart'; // Initialize FirebaseApp await Firebase.initializeApp(  options: DefaultFirebaseOptions.currentPlatform, ); // Initialize the Gemini Developer API backend service // Create a `GenerativeModel` instance with a model that supports your use case final model =  FirebaseAI.googleAI().generativeModel(model: 'gemini-2.5-flash'); // Provide a text prompt to include with the video final prompt = TextPart("What's in the video?"); // Prepare video for input final video = await File('video0.mp4').readAsBytes(); // Provide the video as `Data` with the appropriate mimetype final videoPart = InlineDataPart('video/mp4', video); // To stream generated text output, call generateContentStream with the text and image final response = await model.generateContentStream([  Content.multi([prompt,videoPart]) ]); await for (final chunk in response) {  print(chunk.text); } 

 using Firebase; using Firebase.AI; // Initialize the Gemini Developer API backend service var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()); // Create a `GenerativeModel` instance with a model that supports your use case var model = ai.GetGenerativeModel(modelName: "gemini-2.5-flash"); // Provide the video as `data` with the appropriate MIME type. var video = ModelContent.InlineData("video/mp4",  System.IO.File.ReadAllBytes(System.IO.Path.Combine(  UnityEngine.Application.streamingAssetsPath, "yourVideo.mp4"))); // Provide a text prompt to include with the video var prompt = ModelContent.Text("What is in the video?"); // To stream generated text output, call GenerateContentStreamAsync with the text and video var responseStream = model.GenerateContentStreamAsync(new [] { video, prompt }); await foreach (var response in responseStream) {  if (!string.IsNullOrWhiteSpace(response.Text)) {  UnityEngine.Debug.Log(response.Text);  } }