स्मार्ट Android ऐप्लिकेशन बनाएं: ऐप्लिकेशन में एजेंटिक वर्कफ़्लो
पढ़ने में लगने वाला समय: 9 मिनट
"इंटेलिजेंट Android ऐप्लिकेशन बनाएं" ब्लॉग पोस्ट सीरीज़ में आपका फिर से स्वागत है. इसमें आपको किसी बेसिक Android ऐप्लिकेशन को, उपयोगकर्ता की दिलचस्पी के हिसाब से, इंटेलिजेंट, और एजेंटिक अनुभव देने वाले ऐप्लिकेशन में बदलने का तरीका बताया जाता है. हमारी पिछली पोस्ट में, आपने AppFunctions का इस्तेमाल करके इंटेलिजेंस सिस्टम से कनेक्ट करने का तरीका सीखा.
इस पोस्ट में, क्लाउड में चलने वाले, अपने-आप काम करने वाले इन-ऐप्लिकेशन एजेंटिक वर्कफ़्लो बनाने का तरीका बताया गया है.
कभी-कभी कोई टास्क इतना जटिल होता है कि उसे एक ही डिवाइस सेशन में पूरा नहीं किया जा सकता. उदाहरण के लिए, छुट्टियों के लिए यात्रा की पूरी योजना बुक करने में, फ़्लाइट के समय को मैनेज करना, होटल के कमरे चुनना, म्यूज़ियम के टिकट बुक करना, और रेस्टोरेंट के रिज़र्वेशन की योजना बनाना शामिल है. अगर इस प्रोसेस को सीधे किसी फ़ोन या टैबलेट पर चलाया जाता है, तो हो सकता है कि ऐप्लिकेशन बंद हो जाए और आपकी प्रोग्रेस मिट जाए. फ़ोन पर इन सभी चरणों और एपीआई क्रेडेंशियल को मैनेज करना भी मुश्किल हो जाता है.
लंबे समय तक चलने वाले और कई चरणों वाले इन वर्कफ़्लो के लिए, खुद होस्ट किए गए कस्टम बैकएंड का इस्तेमाल किया जा सकता है. बैकएंड, बुकिंग एजेंट को बैकग्राउंड में चलाता है. वहीं, Android ऐप्लिकेशन सेशन से कनेक्ट होता है, प्रोग्रेस को विज़ुअलाइज़ करता है, और ज़रूरत पड़ने पर ही उपयोगकर्ता से इनपुट का अनुरोध करता है.
क्लाउड पर होस्ट किए गए एजेंटिक बैकएंड का इस्तेमाल करने के कुछ फ़ायदे हैं:
- बैकग्राउंड में काम करना: बुकिंग एजेंट, क्लाउड में अपने-आप काम करते हैं. इसलिए, अगर मोबाइल ऐप्लिकेशन बैकग्राउंड में चला जाता है या इंटरनेट कनेक्शन बंद हो जाता है, तो भी बुकिंग की प्रोसेस नहीं रुकती.
- एक से ज़्यादा एजेंट के बीच जटिल टास्क को मैनेज करना: कोऑर्डिनेटर एजेंट, बुकिंग की ज़िम्मेदारी खास तौर पर बनाए गए सब-एजेंट को सौंप सकता है. साथ ही, उनके बीच की डिपेंडेंसी को मैनेज कर सकता है.
- क्लाइंट-एग्नोस्टिक यूज़र इंटरफ़ेस (यूआई) रेंडरिंग: बैकएंड, इंटरफ़ेस के स्ट्रक्चर के बारे में डाइनैमिक तौर पर बताता है. इससे आपको क्लाइंट का नया वर्शन रिलीज़ किए बिना, यूज़र इंटरफ़ेस (यूआई) लेआउट को अपडेट करने की सुविधा मिलती है.
इन फ़ायदों को ध्यान में रखते हुए, हमने Jetpacker में बुकिंग असिस्टेंट जोड़ा है. यह फ़्लाइट, होटल, म्यूज़ियम, और रेस्टोरेंट की बुकिंग को मैनेज करता है. आइए, देखते हैं कि हमने एजेंट डेवलपमेंट किट (एडीके) की मदद से, मल्टी-एजेंट सिस्टम को कैसे तैयार किया. इसमें एजेंट-यूज़र इंटरैक्शन प्रोटोकॉल (AG-UI) और एजेंट-टू-यूज़र इंटरफ़ेस प्रोटोकॉल (A2UI) का इस्तेमाल किया गया है, ताकि Jetpack Compose में इंटरैक्टिव कार्ड भेजे और दिखाए जा सकें.
ADK एजेंट की मदद से मुश्किल वर्कफ़्लो को आसान बनाना
कस्टम REST एंडपॉइंट या जटिल वेब सॉकेट का इस्तेमाल करके, मैन्युअल तरीके से ऑर्केस्ट्रेशन फ़्लो को मैनेज करने के बजाय, Agent Development Kit (ADK) का इस्तेमाल किया जा सकता है. एडीके की मदद से, एजेंट तय किए जा सकते हैं और उन्हें Python फ़ंक्शन टूल से लैस किया जा सकता है. इससे डेटाबेस से क्वेरी की जा सकती है और बुकिंग की जा सकती है.
यहां एक आसान एजेंट को तय करने और उसे ADK का इस्तेमाल करके चलाने का तरीका बताया गया है:
# server/main.py
# Note: ADK supports many different coding languages. For now, we use the Python version as it includes support for A2UI which we'll use later in this blog post.
from google.adk import Agent
from google.adk.runners import InMemoryRunner
from google.adk.tools import FunctionTool
# Define custom tools to interact with database
def search_flights(destination: str, date: str) -> list[str]:
# In production, here you would query our flight database and return dynamic results
return ["10:00 AM", "2:00 PM"]
def reserve_flight(flight_time: str) -> str:
# In production, here you would save the reservation transaction
return "Reserved flight at " + flight_time
# Instantiate the booking agent with specialized tools
flight_agent = Agent(
name="Flight Booker",
model="gemini-3.1-flash-lite",
instruction="Help the user search for flights and book a reservation.",
tools=[
FunctionTool(search_flights),
FunctionTool(reserve_flight, require_confirmation=True)
]
)
# Run the agent in memory using a session ID
runner = InMemoryRunner(flight_agent)
async for event in runner.run_async(user_id=user_id, session_id=session_id):
if event.content:
print("Agent said:", event.content)इस सेटअप का इस्तेमाल करके एजेंट को चलाने पर, ADK आपके लिए उसे चलाने के चरणों को मैनेज करता है. यह बातचीत के कॉन्टेक्स्ट को अपने-आप ट्रैक करता है. साथ ही, उपयोगकर्ता और मॉडल के बीच मैसेज को रूट करता है. इसके अलावा, मॉडल के अनुरोध करने पर, रजिस्टर किए गए टूल को एक्ज़ीक्यूट करता है. इससे आपको साफ़-सुथरा प्रोसीजरल लॉजिक लिखने पर फ़ोकस करने में मदद मिलती है. वहीं, फ़्रेमवर्क बैकग्राउंड में ऑर्केस्ट्रेशन को मैनेज करता है.
इस बैकएंड एजेंट को हमारे Jetpacker ऐप्लिकेशन से कनेक्ट करने के लिए, सर्वर को डिवाइस पर रीयल टाइम में अपडेट स्ट्रीम करने का तरीका चाहिए. इसे AG-UI प्रोटोकॉल का इस्तेमाल करके मैनेज किया जाता है. एजेंट को फ़ोन पर, इंटरैक्टिव कॉम्पोनेंट (जैसे, विकल्प चुनने वाले टूल और सीटिंग ग्रिड) के बारे में बताने और उन्हें डाइनैमिक तौर पर अपडेट करने के लिए, एक स्ट्रक्चर्ड तरीके की भी ज़रूरत होती है. इसके लिए, A2UI प्रोटोकॉल का इस्तेमाल किया जाता है.
AG-UI की मदद से, एजेंट और क्लाइंट के बीच कम्यूनिकेशन को स्टैंडर्ड बनाना
क्लाउड में एजेंट चलाने और Android पर यूज़र इंटरफ़ेस (यूआई) रेंडर करने के लिए, एक स्टैंडर्ड कम्यूनिकेशन चैनल की ज़रूरत होती है. इसके लिए, आपको AG-UI प्रोटोकॉल का इस्तेमाल करना होगा.
एजी-यूआई, दोनों तरफ़ से काम करने वाला ट्रांसपोर्ट लेयर प्रोटोकॉल है. यह एजेंट और यूज़र इंटरफ़ेस (यूआई) क्लाइंट के बीच, मैसेज के टाइप को स्टैंडर्ड बनाता है. एजेंट, क्लाइंट को लाइफ़साइकल इवेंट, टेक्स्ट मैसेज, टूल कॉल, और स्टेट मैनेजमेंट के बारे में जानकारी दे सकता है. इसके बाद, क्लाइंट, एजेंट को उपयोगकर्ता के टेक्स्ट मैसेज, टूल कॉल के नतीजे, और कस्टम ऐक्शन इवेंट वापस भेज सकता है.
सर्वर साइड पर, यह स्टैंडर्ड सर्वर-सेंट इवेंट के तौर पर फ़ॉर्मैट किए गए अपडेट दिखाता है. जैसे, JSON डेल्टा वाला event: TEXT_MESSAGE_CONTENT. Android पर, Kotlin SDK इस स्ट्रीम को सुनता है और पेलोड को टाइप-सेफ़ क्लाइंट इवेंट पर अपने-आप मैप करता है:
// BookingAssistantViewModel.kt import com.agui.client.agent.HttpAgent import com.agui.client.agent.HttpAgentConfig import com.agui.core.types.RunAgentInput import com.agui.core.types.UserMessage import com.agui.core.types.TextMessageStartEvent import com.agui.core.types.TextMessageContentEvent import com.agui.core.types.TextMessageEndEvent val config = HttpAgentConfig( agentId = "booking-assistant", threadId = threadId, url = "https://<your-backend-url>" ) val agent = HttpAgent(config, httpClient) // Set up the input with the session thread and user instruction val input = RunAgentInput( threadId = threadId, runId = runId, messages = listOf(UserMessage("Book a flight to Paris")) ) // Run the agent flow and collect lifecycle events agent.runAgentObservable(input) .collect { event -> when (event) { is TextMessageStartEvent -> { /* ... */ } is TextMessageContentEvent -> { /* ... */ } is TextMessageEndEvent -> { // Handle the completed message } } }
इसके बाद, स्टैंडर्ड AG-UI इवेंट के इन अलग-अलग टाइप को रेंडर करने के लिए, यूज़र इंटरफ़ेस (यूआई) लिखा जा सकता है. इससे आपको "चैटबॉट" का अनुभव मिलेगा:
A2UI के साथ, एजेंट को यूज़र इंटरफ़ेस (यूआई) के बारे में बताने की सुविधा
पारंपरिक चैटबॉट आम तौर पर, सादा टेक्स्ट या कस्टम JSON पेलोड दिखाते हैं. जटिल इंटरफ़ेस बनाते समय, क्लाइंट ऐप्लिकेशन को इन पेलोड को पार्स करना होता है. साथ ही, उन्हें पहले से बनी खास स्क्रीन पर मैप करना होता है. इससे एक डिपेंडेंसी बनती है: जब भी कोई नई सुविधा जोड़ी जाती है, लेआउट बदला जाता है या उपयोगकर्ता के नए इंटरैक्शन के लिए सहायता दी जाती है, तो आपको बैकएंड एजेंट और मोबाइल ऐप्लिकेशन, दोनों को अपडेट करना पड़ता है. इसके लिए, ऐप्लिकेशन का अपडेट पब्लिश करना होगा और उपयोगकर्ताओं के इसे इंस्टॉल करने का इंतज़ार करना होगा.
इस समस्या को हल करने के लिए, A2UI प्रोटोकॉल का इस्तेमाल करें. A2UI की मदद से, एजेंट यूज़र इंटरफ़ेस (यूआई) के कॉम्पोनेंट के बारे में बता सकते हैं, ताकि उन्हें क्लाइंट पर डाइनैमिक तौर पर रेंडर किया जा सके. क्लाइंट ऐप्लिकेशन, उन कॉम्पोनेंट का कैटलॉग तय करता है जो वह इस्तेमाल करता है. इसके बाद, सर्वर एक JSON पेलोड भेजता है, जिसमें कॉम्पोनेंट के लेआउट और प्रॉपर्टी की जानकारी होती है:
{
"version": "v0.9",
"updateComponents": {
"surfaceId": "Flight Reservation",
"components": [
{
"id": "flight_option_picker",
"component": "InteractiveOptionPicker",
"properties": {
"prompt": "Select a flight time:",
"options": [
"10:00 AM",
"2:00 PM"
],
"selectedIdx": null,
"confirmBtnText": "Confirm Flight"
}
}
]
}
}सर्वर यह तय करता है कि कैटलॉग के कौनसे कॉम्पोनेंट रेंडर करने हैं. साथ ही, उनकी चालू प्रॉपर्टी वैल्यू भी तय करता है. इससे क्लाइंट के विज़ुअल लागू करने की जानकारी, एजेंट के वर्कफ़्लो की स्थिति से अलग हो जाती है.
बैकएंड यूज़र इंटरफ़ेस (यूआई) स्कीमा डिज़ाइन करना
एजेंट को इन JSON पेलोड को सही तरीके से जनरेट करने के लिए, यह जानना ज़रूरी है कि कौनसे कॉम्पोनेंट उपलब्ध हैं और वे किन प्रॉपर्टी को स्वीकार करते हैं.
इसके लिए, ADK A2UI इंटिग्रेशन का इस्तेमाल करें. हमारे कैटलॉग में मौजूद हर कॉम्पोनेंट के लिए, मैन्युअल तरीके से प्रॉम्प्ट के निर्देश लिखने के बजाय, A2uiSchemaManager उनके JSON स्कीमा और लेआउट के निर्देशों को सीधे सिस्टम प्रॉम्प्ट में कंपाइल करता है. इससे यह पक्का होता है कि मॉडल, मान्य A2UI पेलोड जनरेट करने के लिए, सही स्ट्रक्चर और फ़ॉर्मैटिंग के नियमों को सीखे:
# server/main.py
from a2ui.schema.manager import A2uiSchemaManager
from a2ui.schema.constants import VERSION_0_9
from a2ui.schema.catalog import CatalogConfig
from a2ui.basic_catalog.provider import BasicCatalog
# Initialize A2UI Schema Manager with custom booking component catalog
schema_manager = A2uiSchemaManager(
version=VERSION_0_9,
catalogs=[
BasicCatalog.get_config(version=VERSION_0_9),
CatalogConfig.from_path(
name="https://example.com/catalogs/booking_assistant/v1/catalog.json",
catalog_path="booking_catalog.json"
)
]
)
# Compile prompt instructions including the A2UI JSON schema
A2UI_SYSTEM_INSTRUCTION = schema_manager.generate_system_prompt(
role_description="You are a helpful travel booking assistant.",
ui_description="Use InteractiveOptionPicker for choices, SeatSelectionPicker for seat selection...",
include_schema=True,
include_examples=True,
allowed_components=["InteractiveOptionPicker", "SeatSelectionPicker", "BookingStatus"]
)जनरेट किए गए इस सिस्टम निर्देश की मदद से, एलएलएम को स्कीमा लेआउट में शामिल किया जाता है. साथ ही, उसे कॉम्पोनेंट के अपडेट तैयार करने का सटीक तरीका पता होता है. इन अपडेट को Android क्लाइंट रेंडर कर सकता है.
Jetpack Compose की मदद से, A2UI को नेटिव तौर पर रेंडर करना
Android पर इन कॉम्पोनेंट ट्री को नेटिव तौर पर रेंडर करने के लिए, Jetpack Compose A2UI रेंडरर की नई लाइब्रेरी का इस्तेमाल करें.
सबसे पहले, हमारे मॉड्यूल की build.gradle.kts फ़ाइल में डिपेंडेंसी जोड़ें:
// android/feature/trip/booking_assistant/build.gradle.kts dependencies { implementation("androidx.a2ui:a2ui-model:1.0.0-alpha01") implementation("androidx.a2ui.compose:compose-runtime:1.0.0-alpha01") implementation("androidx.a2ui.compose:compose-ui:1.0.0-alpha01") implementation("androidx.compose.material3:material3-a2ui:1.0.0-alpha01") }
कैटलॉग में मौजूद हर कॉम्पोनेंट क्लास (जैसे, BookingStatusComponent) यह तय करती है कि JSON पेलोड से मिली प्रॉपर्टी को Jetpack Compose के कंपोज़ेबल फ़ंक्शन में कैसे मैप किया जाए.
कैटलॉग में कस्टम कॉम्पोनेंट रजिस्टर करें:
// CustomBookingAssistantCatalog.kt import androidx.a2ui.compose.ui.A2uiCatalog fun bookingAssistantCatalog(): A2uiCatalog { return A2uiCatalog( catalogId = "https://example.com/catalogs/booking_assistant/v1/catalog.json", components = listOf( InteractiveOptionPickerComponent(), SeatSelectionPickerComponent(), BookingStatusComponent() ) ) }
सलाह: Jetpacker, बुकिंग फ़्लो के लिए बनाए गए कस्टम कॉम्पोनेंट (InteractiveOptionPicker, SeatSelectionPicker, BookingStatus) लागू करता है. अगर आपका एजेंट टेक्स्ट, कार्ड, बटन, लाइन, कॉलम, चेकबॉक्स, और तारीख-समय चुनने वाले टूल जैसे स्टैंडर्ड एलिमेंट का इस्तेमाल करता है, तो material3-a2ui आपको materialA2uiBasicCatalogV1(...) भी उपलब्ध कराता है. इससे आपको इस्तेमाल के लिए तैयार Material 3 कॉम्पोनेंट मिलते हैं. इसके लिए, आपको कोई कस्टम कॉम्पोनेंट लिखने की ज़रूरत नहीं पड़ती.
ध्यान दें: बैकएंड और मोबाइल क्लाइंट को अलाइन रखने के लिए, दोनों एक ही कैटलॉग डेफ़िनिशन आईडी (https://example.com/catalogs/booking_assistant/v1/catalog.json) का इस्तेमाल करते हैं. अगर बैकएंड कैटलॉग में प्रॉपर्टी जोड़ी जाती हैं या उनमें बदलाव किया जाता है, तो आपको वर्शन नंबर बढ़ाना होगा. साथ ही, पार्स करने से जुड़ी गड़बड़ियों को रोकने के लिए, मैच होने वाली Kotlin कॉम्पोनेंट क्लास को अपडेट करना होगा.
BookingAssistantViewModel में, A2uiMessageProcessor का इस्तेमाल करके A2UI मैसेज प्रोसेस करें और हमारे ऐक्टिव प्लैटफ़ॉर्म अपडेट करें:
// BookingAssistantViewModel.kt import androidx.lifecycle.ViewModel import androidx.a2ui.model.processor.A2uiSurfaceModel import androidx.a2ui.compose.ui.A2uiMessageProcessor import kotlinx.coroutines.flow.StateFlow class BookingAssistantViewModel : ViewModel() { private val messageProcessor = A2uiMessageProcessor( catalogs = listOf(bookingAssistantCatalog()) ) val activeSurfaces: StateFlow<List<A2uiSurfaceModel>> = messageProcessor.activeSurfaces init { viewModelScope.launch(Dispatchers.Default) { processor.collectMessages() } } // ... }
Compose स्क्रीन पर, इन सरफ़ेस को इकट्ठा करें और androidx.compose.material3:material3-a2ui के आधिकारिक A2uiSurface कंपोज़ेबल का इस्तेमाल करके, हर एक को रेंडर करें. A2uiSurface, रिएक्टिव कॉम्पोनेंट की स्थिति पर नज़र रखने, Material 3 के लोडिंग इंडिकेटर, गड़बड़ी के फ़ॉलबैक, और अपडेट के बीच ऐनिमेटेड ट्रांज़िशन को अपने-आप मैनेज करता है:
// BookingAssistantScreen.kt import androidx.compose.runtime.Composable import androidx.compose.runtime.collectAsState import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items import androidx.compose.material3.a2ui.A2uiSurface @Composable fun BookingAssistantScreen( viewModel: BookingAssistantViewModel, modifier: Modifier = Modifier ) { val activeSurfaces by viewModel.activeSurfaces.collectAsState() LazyColumn( modifier = modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(16.dp) ) { items(activeSurfaces) { surfaceModel -> Card(modifier = Modifier.fillMaxWidth()) { A2uiSurface( surfaceModel = surfaceModel, modifier = Modifier.fillMaxWidth().wrapContentHeight() ) } } } }
अब आपको बैकएंड में चल रहे हमारे एजेंट से जनरेट किए गए कई यूज़र इंटरफ़ेस (यूआई) दिखेंगे:
पूरी जानकारी को एक जगह इकट्ठा किया जा रहा है
एजेंट के वर्कफ़्लो को क्लाउड में होस्ट करके और AG-UI और A2UI प्रोटोकॉल का एक साथ इस्तेमाल करके, हम डाइनैमिक और नेटिव Android इंटरफ़ेस बना सकते हैं. ये इंटरफ़ेस सीधे एआई मॉडल से मैनेज किए जाते हैं. AG-UI, मैसेज और लाइफ़साइकल इवेंट के लिए रीयल-टाइम में दोनों तरफ़ से स्ट्रीमिंग चैनल बनाता है. वहीं, A2UI की मदद से क्लाउड एजेंट, इंटरैक्टिव यूआई कॉम्पोनेंट के बारे में डाइनैमिक तरीके से जानकारी दे सकता है. इससे क्लाइंट ऐप्लिकेशन, सिलसिलेवार तरीके से बैकएंड ऑर्केस्ट्रेशन लॉजिक से पूरी तरह अलग रहता है.
GitHub पर Jetpacker के लिए पूरा सोर्स कोड देखें. साथ ही, Google के एआई की मदद से इंटेलिजेंट Android ऐप्लिकेशन बनाएं वीडियो देखें. इससे आपको अपने ऐप्लिकेशन में एजेंटिक वर्कफ़्लो को सीधे इंटिग्रेट करने के तरीके के बारे में ज़्यादा जानकारी मिलेगी.
इस ब्लॉग पोस्ट सीरीज़ के अन्य हिस्से देखें:
▪️ पहला हिस्सा: ऐप्लिकेशन के बारे में जानकारी और खास जानकारी.
📱 दूसरा हिस्सा: उपयोगकर्ता के डिवाइस पर मौजूद इंटेलिजेंस. ML Kit के जेन एआई एपीआई और Gemini Nano के बारे में ज़्यादा जानें. इनकी मदद से, निजता को प्राथमिकता देने वाली सुविधाएं बनाई जा सकती हैं. जैसे, यात्रा की योजना की खास जानकारी पाना, रसीद को पार्स करना, और डिवाइस पर ऑडियो प्रोसेस करना.
☁️ तीसरा हिस्सा: हाइब्रिड और क्लाउड रीज़निंग. जानें कि Firebase AI Logic का इस्तेमाल करके, एलएलएम से मिले जवाबों को Google Maps और वेब कॉन्टेक्स्ट जैसे रीयल-वर्ल्ड डेटा के साथ कैसे जोड़ा जा सकता है.
⚙️ चौथा पार्ट: सिस्टम इंटिग्रेशन. AppFunctions का इस्तेमाल करके, Android इंटेलिजेंस सिस्टम के साथ इंटिग्रेट करना.
🤖 पांचवां हिस्सा (यह पोस्ट!): ऐप्लिकेशन में एजेंटिक वर्कफ़्लो. A2UI और ADK की मदद से, बुकिंग की पूरी प्रोसेस में मदद करने वाले असिस्टेंट जोड़कर, ऐप्लिकेशन को बेहतर बनाएं.
क्या आपको Android डेवलपमेंट के बारे में ज़्यादा जानना है? Android Developers को YouTube या LinkedIn पर फ़ॉलो करें!
इस ब्लॉग पोस्ट के सभी कोड स्निपेट, कॉपीराइट की इस सूचना का पालन करते हैं:
Copyright 2026 Google LLC. SPDX-License-Identifier: Apache-2.0
-
कैसे करें"इंटेलिजेंट Android ऐप्लिकेशन बनाएं" ब्लॉग पोस्ट सीरीज़ में आपका फिर से स्वागत है. इसमें हम एक बुनियादी Android ऐप्लिकेशन को, आपकी दिलचस्पी के हिसाब से, इंटेलिजेंट, और एजेंटिक अनुभव देने वाले ऐप्लिकेशन में बदलते हैं.
Thomas Ezan, Jolanda Verhoef, Caren Chang • 8 मिनट में पढ़ें -
कैसे करेंJetpacker, तकनीकी सुविधाओं को दिखाने वाला एक ऐप्लिकेशन है. इसे हमारी टीम ने इस साल के Google I/O के लिए, Antigravity का इस्तेमाल करके बनाया है. Jetpacker का मुख्य मकसद, उपयोगकर्ताओं को उनके अगले रोमांचक सफ़र की योजना बनाने, नई जगहों को एक्सप्लोर करने, और आनंद लेने में मदद करना है.
Jolanda Verhoef • पढ़ने में लगने वाला समय: 4 मिनट -
कैसे करें"इंटेलिजेंट Android ऐप्लिकेशन बनाएं" ब्लॉग पोस्ट सीरीज़ में आपका फिर से स्वागत है. इसमें हम एक बुनियादी Android ऐप्लिकेशन को, आपकी दिलचस्पी के हिसाब से, इंटेलिजेंट, और एजेंटिक अनुभव देने वाले ऐप्लिकेशन में बदलते हैं. हमने अपनी पिछली पोस्ट में Jetpacker के बारे में बताया था. यह एक डेमो ऐप्लिकेशन है, जिसका इस्तेमाल हम इस सीरीज़ में करेंगे.
Caren Chang • 6 मिनट में पढ़ा जा सकता है
Android डेवलपमेंट से जुड़ी ताज़ा अहम जानकारी, हर हफ़्ते अपने इनबॉक्स में पाएं.