संवाद अनुवाद

Active speaker के लिए छोटा simultaneous-interpretation session शुरू करके और दूसरे participant के लिए source तथा target languages बदलकर दो लोगों का बारी-बारी अनुवाद अनुभव बनाएँ।

यह ConversationTranslationDemoController में दिखाया गया product workflow है; इससे अलग ConversationTranslationAPI नहीं जुड़ती।

Animated workflow

Conversation की एक बारी

हर speaker turn का अपना interpretation session होता है। Partner की बारी में language direction उलटें और दोनों turns साथ न चलाएँ।

01Host app

H

Active Speaker चुनें

चुने गए पक्ष से source और target languages तय करें।

02Host app

H

Turn कॉन्फ़िगर करें

इस direction के लिए simultaneous-interpretation configuration बनाएँ।

03AI service

S

Session शुरू करें

Interpretation शुरू करें और मिला session बनाए रखें।

04Host app + डिवाइस

D

Speech दें

AIBuds AI SDK internal recording उपयोग करें या host app/डिवाइस से external PCM दें।

05AI service → app

%

अनुवाद दिखाएँ

Streaming callbacks से definite source और target segments को क्रम दें।

source + target

06Authoritative stop

✓

Turn समाप्त करें

पहले external recording, फिर interpretation service रोकें।

↳Languages बदलने या दूसरे speaker को शुरू करने से पहले active turn समाप्त करें।

आवश्यक शर्तें

• Simultaneous Interpretation की सभी आवश्यक शर्तें पूरी करें।
• Source और target के लिए अलग hyphenated language identifiers उपयोग करें।
• Host app में active speaker, current session, start/stop state और दिखाई गई turn messages track करें।
• दोनों speakers को एक साथ sessions शुरू करने से रोकें।

AI की सहायता से लागू करें

AI से बनाएँ

इस वर्कफ़्लो को AI से लागू करें

आधिकारिक “AIBuds वार्तालाप अनुवाद लागू करें” स्किल से वर्कफ़्लो को अपने ऐप के अनुसार लागू करें।

https://docs-aibuds.github.io/hi/skills/implement-aibuds-conversation-translation को पढ़ें और निर्देशों का पालन करें। इस स्किल से “AIBuds वार्तालाप अनुवाद लागू करें” को इस iOS प्रोजेक्ट में लागू करें और परिणाम सत्यापित करें।

आधिकारिक स्किल देखें↗

API Reference

संवाद अनुवाद में startSimultaneousInterpretation, stopSimultaneousInterpretation और SimultaneousInterpretationConfig उपयोग होते हैं।

पूरे public declarations और callback contract के लिए Simultaneous Interpretation देखें।

उपयोग के उदाहरण

Speaker की बारी शुरू करें

Demo में “Me” को myLanguage → partnerLanguage और “Partner” को उलटी दिशा से map किया गया है। नीचे के helpers resolved direction लेते हैं, जिससे product state स्पष्ट रहती है।

Swift

Swift

func startConversationTurn(source: String, target: String) {
    guard currentSession == nil, source != target else { return }

    let config = SimultaneousInterpretationConfig.default
    config.sourceLanguage = source
    config.targetLanguage = target
    config.usesInternalAudioRecording = true
    config.preferSpeakerOutput = true
    config.enableVoicePlayback = true

    AIBudsAISDK.startSimultaneousInterpretation(
        config,
        onStartSuccess: { session in
            currentSession = session
            setTurnActive(true)
        },
        onStartFailure: { error in
            currentSession = nil
            setTurnActive(false)
            show(error)
        },
        onStopByInterruption: { error in
            currentSession = nil
            setTurnActive(false)
            if let error { show(error) }
        },
        onException: { error in
            showRecoverable(error)
        },
        streamResultHandler: { _, response, error in
            if let error {
                show(error)
                return
            }
            guard let response else { return }
            if response.isSourceTextDefinite { renderSource(response) }
            if response.isTargetTextDefinite { renderTarget(response) }
        },
        onEvent: { event in
            handle(event)
        },
        onFinish: { report in
            currentSession = nil
            setTurnActive(false)
            save(report)
        }
    )
}

Objective-C

Objective-C

- (void)startConversationTurnFrom:(NSString *)source to:(NSString *)target {
    if (self.currentSession != nil || [source isEqualToString:target])
        return;

    AIBudsSimultaneousInterpretationConfig *config =
        [AIBudsSimultaneousInterpretationConfig defaultConfig];
    config.sourceLanguage = source;
    config.targetLanguage = target;
    config.usesInternalAudioRecording = YES;
    config.preferSpeakerOutput = YES;
    config.enableVoicePlayback = YES;

    [AIBudsAISDK startSimultaneousInterpretationWithConfig:config
        onStartSuccess:^(id<AIBudsSimultaneousInterpretationSessionConvertible> session) {
            self.currentSession = session;
            [self setTurnActive:YES];
        }
        onStartFailure:^(NSError *error) {
            self.currentSession = nil;
            [self setTurnActive:NO];
            [self showError:error];
        }
        onStopByInterruption:^(NSError *error) {
            self.currentSession = nil;
            [self setTurnActive:NO];
            if (error != nil)
                [self showError:error];
        }
        onException:^(NSError *error) {
            [self showRecoverableError:error];
        }
        streamResultHandler:^(
            BOOL isFinal, AIBudsSimultaneousInterpretationDataModel *response, NSError *error) {
            if (error != nil) {
                [self showError:error];
                return;
            }
            if (response.isSourceTextDefinite)
                [self renderSource:response];
            if (response.isTargetTextDefinite)
                [self renderTarget:response];
        }
        onEvent:^(AIBudsSimultaneousInterpretationEventModel *event) {
            [self handleEvent:event];
        }
        onFinish:^(AIBudsSimultaneousInterpretationReportModel *report) {
            self.currentSession = nil;
            [self setTurnActive:NO];
            [self saveReport:report];
        }];
}

Active बारी रोकें

currentSession.isRecordingInternally के false होने पर service रोकने से पहले device-side AI recording रोकें, ताकि अंतिम audio सही क्रम में पहुँचे।

Swift

Swift

func stopConversationTurn() {
    guard let session = currentSession else { return }

    if !session.isRecordingInternally,
        let recordingDevice = device as? DeviceAudioRecordingAPI
    {
        recordingDevice.stopAIAudioRecording(.onSite) { _, _ in
            AIBudsAISDK.stopSimultaneousInterpretation()
        }
    } else {
        AIBudsAISDK.stopSimultaneousInterpretation()
    }
}

Objective-C

Objective-C

- (void)stopConversationTurn {
    if (self.currentSession == nil)
        return;

    if (!self.currentSession.isRecordingInternally) {
        id<AIBudsDeviceAudioRecordingAPI> recordingDevice =
            (id<AIBudsDeviceAudioRecordingAPI>)self.device;
        if ([recordingDevice conformsToProtocol:@protocol(AIBudsDeviceAudioRecordingAPI)]) {
            [recordingDevice
                stopAIAudioRecordingWithScene:AIBudsRecordingSceneOnSite
                                   completion:^(__unused BOOL success, __unused NSError *error) {
                                       [AIBudsAISDK stopSimultaneousInterpretation];
                                   }];
            return;
        }
    }
    [AIBudsAISDK stopSimultaneousInterpretation];
}

त्रुटि प्रबंधन

Startup failure, interruption, recoverable exception, stream error, device-recording failure और final completion को अलग-अलग संभालें। Device recording शुरू होते समय stop request आए तो device start callback पूरा होने तक service stop टालें; Demo इस race को स्पष्ट रूप से track करता है।

ध्यान देने योग्य बातें

• Conversation में कई turns हो सकती हैं, लेकिन एक समय में केवल एक interpretation session active होना चाहिए।
• Languages केवल तब बदलें जब कोई turn active न हो।
• हर callback को सीधे जोड़ने के बजाय निश्चित segments को क्रम देने के लिए source और target sequence fields उपयोग करें।
• External device recording उपयोग करते समय device audio शुरू करने से पहले retained interpretation session को app के PCM forwarding path से जोड़ें, ताकि पहला packet न खोए।