override fun onTranscriptEventsReceived()

in amazon-chime-sdk/src/main/java/com/amazonaws/services/chime/sdk/meetings/internal/audio/DefaultAudioClientObserver.kt [254:343]
88 lines of code
2 McCabe index (conditional complexity)

    override fun onTranscriptEventsReceived(events: Array<out TranscriptEventInternal>?) {
        if (events == null) return

        events.forEach { rawEvent ->
            val event: TranscriptEvent?
            when (rawEvent) {
                is TranscriptionStatusInternal -> {
                    event = TranscriptionStatus(
                        TranscriptionStatusType.from(rawEvent.type.value),
                        rawEvent.eventTimeMs,
                        rawEvent.transcriptionRegion,
                        rawEvent.transcriptionConfiguration,
                        rawEvent.message
                    )
                }
                is TranscriptInternal -> {
                    val results = mutableListOf<TranscriptResult>()
                    rawEvent.results.forEach { rawResult ->
                        val alternatives = mutableListOf<TranscriptAlternative>()
                        rawResult.alternatives.forEach { rawAlternative ->
                            val items = mutableListOf<TranscriptItem>()
                            rawAlternative.items.forEach { rawItem ->
                                val item = TranscriptItem(
                                    TranscriptItemType.from(rawItem.type.value),
                                    rawItem.startTimeMs,
                                    rawItem.endTimeMs,
                                    AttendeeInfo(
                                        rawItem.attendee.attendeeId,
                                        rawItem.attendee.externalUserId
                                    ),
                                    rawItem.content,
                                    rawItem.vocabularyFilterMatch,
                                    rawItem.confidence,
                                    rawItem.stable
                                )
                                items.add(item)
                            }
                            val entities = rawAlternative.entities?.let {
                                it.map { rawEntity ->
                                    TranscriptEntity(
                                        rawEntity.category,
                                        rawEntity.confidence,
                                        rawEntity.content,
                                        rawEntity.startTimeMs,
                                        rawEntity.endTimeMs,
                                        rawEntity.type
                                    )
                                }.toTypedArray() ?: run { null }
                            }
                            val alternative = TranscriptAlternative(
                                items.toTypedArray(),
                                entities,
                                rawAlternative.transcript
                            )
                            alternatives.add(alternative)
                        }
                        val languageIdentification = rawResult.languageIdentification?.let {
                            it.map { rawLanguageIdentification ->
                                TranscriptLanguageWithScore(
                                    rawLanguageIdentification.languageCode,
                                    rawLanguageIdentification.score
                                )
                            }.toTypedArray() ?: run { null }
                        }
                        val result = TranscriptResult(
                            rawResult.resultId,
                            rawResult.channelId,
                            rawResult.isPartial,
                            rawResult.startTimeMs,
                            rawResult.endTimeMs,
                            alternatives.toTypedArray(),
                            rawResult.languageCode,
                            languageIdentification
                        )
                        results.add(result)
                    }
                    event = Transcript(results.toTypedArray())
                } else -> {
                    logger.error(TAG, "Received transcript event in unknown format")
                    event = null
                }
            }

            event?.let { transcriptEvent ->
                ObserverUtils.notifyObserverOnMainThread(transcriptEventObservers) {
                    it.onTranscriptEventReceived(transcriptEvent)
                }
            }
        }
    }