Android SDK

தேவைகள்#

• minSdk 24 (Android 7.0), compileSdk 35.
• Kotlin 2.x மற்றும் Jetpack Compose (SDK-யுடனேயே Compose UI வருகிறது).
• JVM target 17.

SDK தன் transitive சார்புகளை (Coroutines, kotlinx.serialization, OkHttp, Coil, Compose) தானே இழுத்துக்கொள்கிறது, மேலும் தன் manifest-இல் INTERNET அனுமதியை அறிவிக்கிறது — கையால் எதையும் சேர்க்கத் தேவையில்லை.

நிறுவல்#

நூலகம் Maven Central தளத்தில் ai.respondo:respondo-sdk என வெளியிடப்பட்டுள்ளது. உங்கள் repositories-இல் mavenCentral() இருப்பதை உறுதி செய்யுங்கள் (புதிய Android திட்டத்தில் அது இயல்பாகவே இருக்கும்), பிறகு coordinate மூலம் சார்பைச் சேருங்கள்.

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
    }
}

dependencies {
    implementation("ai.respondo:respondo-sdk:0.1.0")
}

தொடக்கமிடல்#

Respondo.init-ஐ ஒரு முறை அழையுங்கள், உங்கள் Compose மரத்தில் RespondoChatHost()-ஐ ஒரு முறை பொருத்துங்கள், பிறகு உங்கள் சொந்தப் பொத்தானிலிருந்து அரட்டையைத் திறங்கள்.

import ai.respondo.sdk.Respondo
import ai.respondo.sdk.RespondoConfig
import ai.respondo.sdk.ui.RespondoChatHost

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        Respondo.init(
            context = this,
            config = RespondoConfig(
                agentId = "<agent-uuid>",   // டாஷ்போர்டிலிருந்து
                channelId = "<channel-uuid>", // விருப்பத்தேர்வு
                // baseUrl தவிர்க்கப்பட்டால் -> https://api.respondo.ai
            ),
        )

        setContent {
            MaterialTheme {
                Box(modifier = Modifier.fillMaxSize()) {
                    Button(onClick = { Respondo.open() }) { Text("Support") }
                    RespondoChatHost() // அரட்டை நிலை OPEN ஆக இருக்கும்போது SDK ஷீட்டைக் காட்டும்
                }
            }
        }
    }
}

எல்லா அழைப்புகளும் Respondo singleton வழியாகச் செல்கின்றன. அவை idempotent, எந்த thread-இலிருந்தும் பாதுகாப்பானவை; init முடிவதற்கு முன் செய்யப்படும் அழைப்புகள் தற்காலிகமாகச் சேமிக்கப்பட்டு, பின்னர் மீண்டும் இயக்கப்படுகின்றன.

பயனர்களை அடையாளம் காணல்#

இயல்பாக ஒவ்வொரு பார்வையாளரும் அநாமதேயமானவர். முதல் முறை தொடங்கும்போது SDK நிலையான visitor_id ஒன்றை உருவாக்கி, அதை உள்ளூர் சேமிப்பில் வைத்திருக்கிறது; அதனால் திரும்பி வரும் பயனர் தன் உரையாடலை மீண்டும் கண்டடைகிறார். செயலியில் பொதிக்க API சாவி எதுவும் இல்லை — ஒவ்வொரு உரையாடலும், backend வழங்கி ஒவ்வொரு செய்தியிலும் முன்நகர்த்தும் உரையாடல்வாரியான session டோக்கனால் பாதுகாக்கப்படுகிறது; எனவே அநாமதேயப் பார்வையாளர் மீண்டும் அங்கீகாரம் பெறவே வேண்டியதில்லை.

உங்கள் பயனர் உள்நுழைந்ததும் identify-ஐ ஒரு முறை அழையுங்கள். இது அவரின் உண்மையான அடையாளத்தை இணைக்கிறது; அதனால் அவரின் வரலாறு சாதனங்களுக்கு இடையேயும் மறுநிறுவல்களுக்குப் பிறகும் அவரைத் தொடர்கிறது, மேலும் உங்கள் இன்பாக்ஸில் உரையாடலுக்கு அருகில் அநாமதேயப் பார்வையாளருக்குப் பதிலாக அவரின் பெயரும் மின்னஞ்சலும் தெரிகின்றன.

userHash என்பது முகவரின் identity_secret-இலிருந்து உங்கள் backend கணக்கிடும் கையொப்பம் — HMAC-SHA256(secret, userId) (userId இல்லாதபோது மின்னஞ்சல்), சிறிய எழுத்து hex ஆகக் குறியீடு செய்யப்பட்டது. இந்த ரகசியம் அடையாளம் உண்மையானது என்பதை நிரூபிக்கிறது; எனவே அது உங்கள் backend-இல் மட்டுமே இருக்க வேண்டும், செயலியுடன் ஒருபோதும் அனுப்பப்படுவதில்லை. முழு சூத்திரத்தையும் சர்வர் பக்க எடுத்துக்காட்டுகளையும் அடையாளச் சரிபார்ப்பு பக்கத்தில் பாருங்கள்.

import ai.respondo.sdk.RespondoIdentity

// userHash உங்கள் backend-இலிருந்து வருகிறது (userId மீது HMAC-SHA256) —
// அதை ஒருபோதும் செயலிக்குள் கணக்கிட வேண்டாம்.
Respondo.identify(
    RespondoIdentity(
        userId = session.userId,
        email = session.email,
        name = session.fullName,
        userHash = session.respondoUserHash,
    ),
)

// வெளியேறும்போது: புஷ் டோக்கனை நீக்குங்கள், அமர்வை ரத்து செய்யுங்கள், புதிய அநாமதேயப் பார்வையாளராகத் தொடங்குங்கள்.
Respondo.clearPushToken()
Respondo.reset()

ஹாஷ் இல்லாவிட்டாலோ தவறாக இருந்தாலோ எந்தப் பிழையும் எழுவதில்லை: backend அமைதியாகப் பார்வையாளரை அநாமதேயமாகவே வைத்திருக்கும், அரட்டை தொடர்ந்து வேலை செய்யும், சரியான ஹாஷ் வழங்கப்படும் வரை சாதனங்களுக்கு இடையிலான இணைப்பை மட்டும் இழப்பீர்கள். முகவருக்கு identity_secret அமைக்கப்பட்டிருந்தால் மட்டுமே சரிபார்ப்பு இயங்கும் — உருவாக்கத்தின் போது அதைக் காலியாக விடுங்கள், அப்போது userId / மின்னஞ்சல் அப்படியே ஏற்கப்படும்.

கவனிக்கத்தக்க மதிப்புகளும் callback-களும்#

நிலையை reactive முறையில் StateFlow ஆகப் படியுங்கள் (Compose-க்கு ஏற்றது) அல்லது imperative முறையில் RespondoListener வழியாகப் படியுங்கள் (செயலி ஐகான் பேட்ஜுக்கு ஏற்றது).

// Reactive: படிக்காதவற்றின் எண்ணிக்கை StateFlow ஆக.
val unread by Respondo.unreadCount.collectAsState()

// Imperative: பேட்ஜுகளுக்கும் அனலிட்டிக்ஸுக்கும் listener.
Respondo.setListener(object : RespondoListener {
    override fun onUnreadChanged(count: Int) { updateAppIconBadge(count) }
    override fun onUrlRequested(url: String): Boolean = tryOpenInternally(url)
})

திரைக் கண்காணிப்பு#

முன்முனைப்பான டீஸர்களும் பக்க அளவிலான இலக்கிடலும் பொருத்திப் பார்க்க, ஒவ்வொரு navigation-இலும் தற்போதைய திரையைத் தெரிவியுங்கள். null அனுப்பினால் அது அழிக்கப்படும்; ஒவ்வொரு மாற்றத்திலும் புதிய திரைக்காக முன்முனைப்பான டீஸர் மீண்டும் மதிப்பீடு செய்யப்படுகிறது.

Respondo.setCurrentScreen("pricing")

அடுத்த படிகள்#

ஆஃப்லைனில் வரும் அலுவலர் பதில்களுக்கு புஷ் அறிவிப்புகளையும், உள்நுழைந்த பயனர்களுக்கு அடையாளச் சரிபார்ப்பையும் அமையுங்கள். முழு API பரப்பு, XML ஹோஸ்ட்களுக்கான Fragment ரேப்பர், சிக்கல் தீர்வு ஆகியவை Android SDK தொடக்க வழிகாட்டியில் விளக்கப்பட்டுள்ளன; SDK மூலக்கோப்புகள் GitHub-இல் பொதுவில் உள்ளன.