How can I access remote transcription events from a private method in LiveKit using Flutter?

Below is an explanation of your options and a sample approach:

---

Why You Can’t Directly Access _onTranscriptionEvent

The method _onTranscriptionEvent is defined as a private method inside the Room class (or another internal class). In Dart the underscore prefix means the method isn’t intended for public use. That means it isn’t exposed through the public API of the LiveKit SDK. In other words, you cannot import or subscribe to this method or its underlying stream from another class without modifying the library code.

---

Options to Consider

1. Use the Public API (if available):
   Check whether LiveKit already exposes the transcription events (including the remote ones) through a public stream or callback. Sometimes the internal event is used to update a local model (for example, the Participant object in participant.dart) which may have a public getter for transcription updates. If so, subscribe to that instead.

2. Extend or Fork the Library:
   If there isn’t a public API yet, you have two choices:

   • Extend the Room Class: Although you cannot override a private method from outside the class (since it’s not accessible), you can either wrap the Room instance or fork the repository and publish your own modified version that exposes a public stream.

     For example, you could add a public Stream in Room that dispatches the transcription events:

     DARTCopied
     // In your fork or local modified version of Room
     class Room {
       // Internal engine events stream (hypothetical)
       final Stream<EngineTranscriptionReceivedEvent> _engineTranscriptionStream;
       
       // Your public stream controller for transcription events.
       final StreamController<EngineTranscriptionReceivedEvent> _transcriptionController =
           StreamController.broadcast();
       
       Room() {
         _engineTranscriptionStream.listen(_onTranscriptionEvent);
       }
       
       // Public getter to subscribe to transcription events.
       Stream<EngineTranscriptionReceivedEvent> get transcriptionStream =>
           _transcriptionController.stream;
       
       // Your original private method now forwards events to the public stream.
       void _onTranscriptionEvent(EngineTranscriptionReceivedEvent event) {
         // Process the event as the original code did...
         
         // Then publish the event to your stream.
         _transcriptionController.add(event);
       }
     }

   • Submit a Feature Request or Pull Request:
     If you prefer to keep using the official LiveKit package, you might want to suggest that the maintainers expose remote transcription events via a public API. This way, both local and remote transcriptions can be handled in your Flutter app without hacking around private methods.

3. Use an Intermediary:
   If you already have control over the LiveKit connection or an engine event bus, and if the engine itself publishes transcription events (even if those are “raw”), subscribe directly to that event stream and filter based on event content (e.g. distinguishing remote transcription). That is, if LiveKit’s engine is exposing these events publicly, you could listen to them separately. Review the available documentation or API reference to verify if such a stream exists.

---

In Summary

• Direct access is not possible: The _onTranscriptionEvent method is private, so you cannot call it from outside its scope.
• Look for a public API: Sometimes the SDK will update participant or room objects with transcription data. Check if there is an existing public stream or callback to subscribe to.
• Extend/Fork if needed: If the feature isn’t exposed, consider extending the Room class (or forking the repository) to add your own public stream for transcription events.
• Feedback to maintainers: A feature request might be the cleanest solution so that future versions expose both local and remote transcription data.

---

Next Steps

1. Verify the available public API in LiveKit for transcription events.
2. If not available, decide whether you want to modify the code locally or submit an enhancement to the maintainers.
3. If modifying locally, add a public stream (as shown in the snippet) to expose the transcription events, then subscribe to that stream in your UI to display both local and remote transcriptions in real‑time.

This approach should allow you to achieve your goal of listing both transcription sources.