డాక్యుమెంటేషన్

iOS SDK

Respondo సపోర్ట్ చాట్ కోసం స్థానిక Swift, SwiftUI క్లయింట్ — మూడో పక్షం డిపెండెన్సీలు ఏవీ లేకుండా.

అవసరాలు#

  • iOS 15.0+ (iOS 16+లో షీట్ డిటెంట్‌లు మరింత సూక్ష్మం, అంతకు కింద సిస్టమ్ ఫాల్‌బ్యాక్).
  • Swift 5.9+.
  • మూడో పక్షం డిపెండెన్సీలు సున్నా — కేవలం Foundation, Swift Concurrency, SwiftUI, UIKit మాత్రమే.

మీరు RespondoSDK ప్రొడక్ట్‌పై ఆధారపడతారు; అది క్రాస్-ప్లాట్‌ఫామ్ RespondoCoreను తిరిగి ఎక్స్‌పోర్ట్ చేస్తుంది.

ఇన్‌స్టాలేషన్#

ప్యాకేజీని Swift Package Managerతో జోడించండి. Xcodeలో: File → Add Package Dependencies… ఎంచుకుని https://github.com/respondo-app/sdk-iosఇవ్వండి; లేదా మీ సొంత Package.swiftలో దాన్ని ప్రకటించి, ఆపై RespondoSDK ప్రొడక్ట్‌పై ఆధారపడండి.

Package.swiftswift
dependencies: [
    .package(url: "https://github.com/respondo-app/sdk-ios", from: "0.1.0")
],
targets: [
    .target(
        name: "MyApp",
        dependencies: [
            .product(name: "RespondoSDK", package: "sdk-ios")
        ]
    )
]

ఆ తర్వాత కోడ్‌లో దీన్ని import చేయండి:

Swiftswift
import RespondoSDK

ఇనిషియలైజేషన్#

యాప్ ప్రారంభంలో ఒకసారి ఇనిషియలైజ్ చేసి, ఆ తర్వాత ఎక్కడి నుంచైనా Respondo.open()ని కాల్ చేయండి. లైఫ్‌సైకిల్ మెథడ్ పేరు initialize (init అనే పదాన్ని భాషే రిజర్వ్ చేసుకుంది).

MyApp.swiftswift
import SwiftUI
import RespondoSDK

@main
struct MyApp: App {
    init() {
        Respondo.initialize(
            RespondoConfig(
                agentId: "<agent-uuid>",
                channelId: "<channel-uuid>"
                // baseUrl nil అయితే -> https://api.respondo.ai
            )
        )
    }

    var body: some Scene {
        WindowGroup {
            Button("Support") { Respondo.open() }
        }
    }
}

Respondo ఫసాడ్ థ్రెడ్-సేఫ్. initialize తర్వాత వెంటనే చేసిన కాల్‌లు క్యూలో నిలిచి, ఎసింక్ init పూర్తయ్యాక అమలవుతాయి.

వినియోగదారులను గుర్తించడం#

డిఫాల్ట్‌గా ప్రతి సందర్శకుడూ అనామకుడే. మొదటిసారి యాప్ తెరిచినప్పుడు SDK స్థిరమైన visitor_idని తయారుచేసి దాన్ని కీచెయిన్‌లో ఉంచుతుంది, అందుకే తిరిగి వచ్చిన వినియోగదారుకు తన సంభాషణ మళ్లీ దొరుకుతుంది. యాప్‌లో పొందుపరచాల్సిన API కీ ఏదీ లేదు — ప్రతి సంభాషణనూ దానికే ప్రత్యేకమైన సెషన్ టోకెన్ కాపాడుతుంది; బ్యాకెండ్ ఆ టోకెన్‌ను జారీ చేసి ప్రతి మెసేజ్‌కూ ముందుకు జరుపుతుంది, కాబట్టి అనామక సందర్శకుడు మళ్లీ ప్రామాణీకరణ చేయాల్సిన అవసరమే రాదు.

మీ వినియోగదారు సైన్ ఇన్ అయిన వెంటనే identifyని కాల్ చేయండి. ఇది వారి అసలు గుర్తింపును జతచేస్తుంది, తద్వారా పరికరాలు మారినా, యాప్ మళ్లీ ఇన్‌స్టాల్ చేసినా వారి చరిత్ర వారితోనే ఉంటుంది; మీ ఇన్‌బాక్స్‌లో సంభాషణ పక్కన అనామక సందర్శకుడికి బదులు వారి పేరు, ఈమెయిల్ కనిపిస్తాయి.

userHash అనేది ఏజెంట్ యొక్క identity_secret నుంచి మీ బ్యాకెండ్ లెక్కించే సంతకం — HMAC-SHA256(secret, userId) (userId లేనప్పుడు ఈమెయిల్‌పై), చిన్న అక్షరాల hex రూపంలో. గుర్తింపు నిజమైనదని ఈ సీక్రెట్ నిరూపిస్తుంది, కాబట్టి అది మీ బ్యాకెండ్‌లో మాత్రమే ఉండాలి, యాప్‌తో పాటు ఎప్పుడూ పంపకూడదు. పూర్తి సూత్రం, సర్వర్ వైపు ఉదాహరణల కోసం గుర్తింపు ధ్రువీకరణ పేజీ చూడండి.

Swiftswift
// userHash మీ బ్యాకెండ్ నుంచి వస్తుంది (userId పై HMAC-SHA256) —
// దాన్ని యాప్‌లో ఎప్పుడూ లెక్కించవద్దు.
Respondo.identify(
    RespondoIdentity(
        userId: session.userId,
        email: session.email,
        name: session.fullName,
        userHash: session.respondoUserHash
    )
)

// లాగ్ అవుట్‌లో: సెషన్‌ను రద్దు చేసి, కొత్త అనామక సందర్శకుడితో మొదలుపెట్టండి.
Respondo.reset()

హాష్ లేకపోయినా, తప్పుగా ఉన్నా ఏదీ కుప్పకూలదు: బ్యాకెండ్ నిశ్శబ్దంగా సందర్శకుడిని అనామకుడిగానే ఉంచుతుంది, చాట్ యథావిధిగా పనిచేస్తుంది, సరైన హాష్ అందేవరకు మీరు కేవలం పరికరాల మధ్య అనుసంధానాన్ని కోల్పోతారు. ఏజెంట్‌కు identity_secret సెట్ చేసినప్పుడు మాత్రమే ధ్రువీకరణ జరుగుతుంది — డెవలప్‌మెంట్ సమయంలో దాన్ని ఖాళీగా వదిలేస్తే userId / ఈమెయిల్ ఉన్నదున్నట్టుగానే ఆమోదించబడతాయి.

అబ్జర్వబుల్‌లు & డెలిగేట్#

స్థితిని సింక్రనస్ గెట్టర్‌ల ద్వారా, రియాక్టివ్ AsyncStreamల ద్వారా, లేదా RespondoDelegate ద్వారా చదవండి. స్ట్రీమ్‌లూ, డెలిగేట్ కాల్‌బ్యాక్‌లూ మెయిన్ యాక్టర్‌పైనే వస్తాయి.

Swiftswift
// చదవని మెసేజ్‌ల సంఖ్యల రియాక్టివ్ స్ట్రీమ్.
Task {
    for await count in Respondo.unreadCountStream {
        updateBadge(count)
    }
}

// బ్యాడ్జ్‌లు, డీప్-లింక్ ఫాల్‌బ్యాక్‌ల కోసం డెలిగేట్.
final class SupportCoordinator: RespondoDelegate {
    init() { Respondo.delegate = self }
    func respondoUnreadChanged(_ count: Int) {
        UIApplication.shared.applicationIconBadgeNumber = count
    }
}

స్క్రీన్ ట్రాకింగ్#

ప్రతి నావిగేషన్‌లో ప్రస్తుత స్క్రీన్‌ను నివేదించండి — ముందస్తు టీజర్లు, పేజీ-స్థాయి టార్గెటింగ్ దానితో సరిపోల్చగలుగుతాయి (static func setCurrentScreen(_ name: String?)). క్లియర్ చేయడానికి nil పంపండి; ప్రతి మార్పులోనూ కొత్త స్క్రీన్‌కు ముందస్తు టీజర్ మళ్లీ మూల్యాంకనం అవుతుంది.

Swiftswift
Respondo.setCurrentScreen("pricing")

తదుపరి దశలు#

పుష్ నోటిఫికేషన్‌లు, గుర్తింపు ధ్రువీకరణ అమర్చుకోండి. UIKit ర్యాపర్ RespondoChatViewController, పూర్తి డెలిగేట్ ఉపరితలం, సమస్యల పరిష్కారం — ఇవన్నీ iOS SDK ప్రారంభ మార్గదర్శిలో ఉన్నాయి; SDK సోర్స్‌లు GitHubలో బహిరంగంగా అందుబాటులో ఉన్నాయి.