สร้างข้อความโดยใช้ 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);   } }