ஆவணங்கள்

iOS SDK

Respondo ஆதரவு அரட்டைக்கான, மூன்றாம் தரப்புச் சார்புகள் எதுவுமே இல்லாத, Swift மற்றும் SwiftUI அடிப்படையிலான நேட்டிவ் கிளையண்ட்.

தேவைகள்#

  • iOS 15.0+ (iOS 16+ இல் நுட்பமான sheet detents, அதற்குக் கீழே கணினியின் இயல்பு நிலைக்கு மாறும்).
  • 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 முகப்பு thread-பாதுகாப்பானது. initialize-க்குப் பின் உடனே செய்யப்படும் அழைப்புகள் வரிசையில் வைக்கப்பட்டு, async தொடக்கம் முடிந்ததும் செயல்படுத்தப்படும்.

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

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

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

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

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

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

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

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

நிலையை synchronous getter-களாகவோ, reactive AsyncStream-களாகவோ, அல்லது RespondoDelegate வழியாகவோ படிக்கலாம். Stream-களும் delegate callback-களும் main actor-இல் வந்து சேரும்.

Swiftswift
// படிக்காதவற்றின் எண்ணிக்கைக்கான reactive stream.
Task {
    for await count in Respondo.unreadCountStream {
        updateBadge(count)
    }
}

// பேட்ஜுகளுக்கும் deep link-க்கான மாற்று வழிகளுக்கும் delegate.
final class SupportCoordinator: RespondoDelegate {
    init() { Respondo.delegate = self }
    func respondoUnreadChanged(_ count: Int) {
        UIApplication.shared.applicationIconBadgeNumber = count
    }
}

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

முன்முனைப்பான டீஸர்களும் பக்க அளவிலான இலக்கிடலும் பொருத்திப் பார்க்க, ஒவ்வொரு navigation-இலும் தற்போதைய திரையைத் தெரிவியுங்கள் (static func setCurrentScreen(_ name: String?)). nil அனுப்பினால் அது அழிக்கப்படும்; ஒவ்வொரு மாற்றத்திலும் புதிய திரைக்காக முன்முனைப்பான டீஸர் மீண்டும் மதிப்பீடு செய்யப்படுகிறது.

Swiftswift
Respondo.setCurrentScreen("pricing")

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

புஷ் அறிவிப்புகளையும் அடையாளச் சரிபார்ப்பையும் இணைத்துவிடுங்கள். UIKit ரேப்பர் RespondoChatViewController, முழு delegate பரப்பு, சிக்கல் தீர்வு ஆகியவை iOS SDK தொடக்க வழிகாட்டியில் விளக்கப்பட்டுள்ளன; SDK மூலக்கோப்புகள் GitHub-இல் பொதுவில் உள்ளன.