Add spotless check to CI builds (#270)

* add spotless

* fix some format violations

* kotlin styling

* add spotless check to ci

* Update actions and fix spotless check

* ktlint fixes

* more spotless fixes

* more spotless fixes

* turn off annotation lint

* run spotless check first

+# https://editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+max_line_length = 180
+
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.{java,kt,kts,scala,rs,xml,kt.spec,kts.spec,gradle,md}]
+indent_size = 4
+
+[*.{kt,kts}]
+ktlint_code_style = android_studio
+
+# default IntelliJ IDEA style, same as alphabetical, but with "java", "javax", "kotlin" and alias imports in the end of the imports list
+ij_kotlin_imports_layout = *, java.**, javax.**, kotlin.**, ^
+
+ktlint_standard = enabled
+ktlint_standard_annotation = disabled
+ktlint_standard_no-wildcard-imports = disabled
+
+ktlint_standard_trailing-comma-on-call-site = disabled
+ij_kotlin_allow_trailing_comma_on_call_site = true
+ktlint_standard_trailing-comma-on-declaration-site = disabled
+ij_kotlin_allow_trailing_comma = true
+
+ktlint_standard_wrapping = disabled
+
+[*.md]
+trim_trailing_whitespace = false
+max_line_length = unset
+
+[*.yml]
+ij_yaml_spaces_within_brackets = false

@@ -24,18 +24,18 @@ jobs:
         working-directory: ./client-sdk-android
         working-directory: ./client-sdk-android
     steps:
     steps:
     - name: checkout client-sdk-android
     - name: checkout client-sdk-android
-      uses: actions/checkout@v2.3.4
+      uses: actions/checkout@v4.0.0
       with:
       with:
         path: ./client-sdk-android
         path: ./client-sdk-android
         submodules: recursive
         submodules: recursive
 
 
     - name: set up JDK 12
     - name: set up JDK 12
-      uses: actions/setup-java@v2
+      uses: actions/setup-java@v3.12.0
       with:
       with:
         java-version: '12'
         java-version: '12'
         distribution: 'adopt'
         distribution: 'adopt'
 
 
-    - uses: actions/cache@v2
+    - uses: actions/cache@v3.3.2
       with:
       with:
         path: |
         path: |
           ~/.gradle/caches
           ~/.gradle/caches
@@ -45,10 +45,19 @@ jobs:
     - name: Grant execute permission for gradlew
     - name: Grant execute permission for gradlew
       run: chmod +x gradlew
       run: chmod +x gradlew
 
 
+    - name: Gradle clean
+      run: ./gradlew clean
+
+    - name: Spotless check
+      if: github.event_name == 'pull_request'
+      run: |
+        git fetch origin main --depth 1
+        ./gradlew spotlessCheck
+
     - name: Build with Gradle
     - name: Build with Gradle
-      run: ./gradlew clean assembleRelease livekit-android-sdk:testRelease
+      run: ./gradlew assembleRelease livekit-android-sdk:testRelease
 
 
-# TODO: Figure out appropriate place to run this. Takes ~3 mins, so pretty slow.
+      # TODO: Figure out appropriate place to run this. Takes ~3 mins, so pretty slow.
 #    # generates coverage-report.md and publishes as checkrun
 #    # generates coverage-report.md and publishes as checkrun
 #    - name: JaCoCo Code Coverage Report
 #    - name: JaCoCo Code Coverage Report
 #      id: jacoco_reporter
 #      id: jacoco_reporter

+/*
+ * Copyright $YEAR LiveKit, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+

@@ -15,6 +15,7 @@ buildscript {
         classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.19'
         classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.19'
         classpath "io.codearte.gradle.nexus:gradle-nexus-staging-plugin:0.30.0"
         classpath "io.codearte.gradle.nexus:gradle-nexus-staging-plugin:0.30.0"
         classpath 'com.dicedmelon.gradle:jacoco-android:0.1.5'
         classpath 'com.dicedmelon.gradle:jacoco-android:0.1.5'
+        classpath "com.diffplug.spotless:spotless-plugin-gradle:6.21.0"
         // NOTE: Do not place your application dependencies here; they belong
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
         // in the individual module build.gradle files
     }
     }
@@ -27,6 +28,41 @@ subprojects {
         mavenCentral()
         mavenCentral()
         maven { url 'https://jitpack.io' }
         maven { url 'https://jitpack.io' }
     }
     }
+
+    apply plugin: "com.diffplug.spotless"
+    spotless {
+        // optional: limit format enforcement to just the files changed by this feature branch
+        ratchetFrom 'origin/main'
+
+        format 'misc', {
+            // define the files to apply `misc` to
+            target '*.gradle', '*.md', '.gitignore'
+
+            // define the steps to apply to those files
+            trimTrailingWhitespace()
+            indentWithSpaces()
+            endWithNewline()
+        }
+        java {
+            // apply a specific flavor of google-java-format
+            googleJavaFormat('1.17.0').aosp().reflowLongStrings()
+            // fix formatting of type annotations
+            formatAnnotations()
+            // make sure every file has the following copyright header.
+            // optionally, Spotless can set copyright years by digging
+            // through git history (see "license" section below)
+            licenseHeaderFile rootProject.file("LicenseHeaderFile.txt")
+            removeUnusedImports()
+        }
+        kotlin {
+            target("src/*/java/**/*.kt")
+            ktlint("0.50.0")
+                .setEditorConfigPath("$rootDir/.editorconfig")
+            licenseHeaderFile(rootProject.file("LicenseHeaderFile.txt"))
+                .named('license')
+            endWithNewline()
+        }
+    }
 }
 }
 
 
 task clean(type: Delete) {
 task clean(type: Delete) {
@@ -47,8 +83,8 @@ afterEvaluate {
          "createRepository",
          "createRepository",
          "getStagingProfile",
          "getStagingProfile",
          "releaseRepository"]
          "releaseRepository"]
-                .forEach { taskName ->
-                    getTasksByName(taskName, false).forEach { task -> task.enabled = false }
-                }
+            .forEach { taskName ->
+                getTasksByName(taskName, false).forEach { task -> task.enabled = false }
+            }
     }
     }
-}
+}

@@ -184,4 +184,4 @@ afterEvaluate {
             }
             }
         }
         }
     }
     }
-}
+}

@@ -16,5 +16,5 @@ Room is the primary class that manages the connection to the LiveKit Room. It ex
 
 
 # Package io.livekit.android.room.track
 # Package io.livekit.android.room.track
 
 
-`AudioTrack` and `VideoTrack` are the classes that represent the types of media streams that can be 
-subscribed and published.
+`AudioTrack` and `VideoTrack` are the classes that represent the types of media streams that can be
+subscribed and published.

@@ -16,14 +16,12 @@
 
 
 package io.livekit.android
 package io.livekit.android
 
 
-import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.ext.junit.runners.AndroidJUnit4
-
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runner.RunWith
 
 
-import org.junit.Assert.*
-
 /**
 /**
  * Instrumented test, which will execute on an Android device.
  * Instrumented test, which will execute on an Android device.
  *
  *

@@ -19,7 +19,6 @@ package io.livekit.android
 import io.livekit.android.room.ProtocolVersion
 import io.livekit.android.room.ProtocolVersion
 import org.webrtc.PeerConnection
 import org.webrtc.PeerConnection
 
 
-
 data class ConnectOptions(
 data class ConnectOptions(
     /** Auto subscribe to room tracks upon connect, defaults to true */
     /** Auto subscribe to room tracks upon connect, defaults to true */
     val autoSubscribe: Boolean = true,
     val autoSubscribe: Boolean = true,

@@ -122,6 +122,5 @@ class LiveKit {
             room.connect(url, token, connectOptions)
             room.connect(url, token, connectOptions)
             return room
             return room
         }
         }
-
     }
     }
 }
 }

@@ -50,7 +50,6 @@ data class LiveKitOverrides(
     val audioOptions: AudioOptions? = null,
     val audioOptions: AudioOptions? = null,
 )
 )
 
 
-
 class AudioOptions(
 class AudioOptions(
     /**
     /**
      * Override the default output [AudioType].
      * Override the default output [AudioType].
@@ -87,7 +86,7 @@ class AudioOptions(
 sealed class AudioType(
 sealed class AudioType(
     val audioMode: Int,
     val audioMode: Int,
     val audioAttributes: AudioAttributes,
     val audioAttributes: AudioAttributes,
-    val audioStreamType: Int
+    val audioStreamType: Int,
 ) {
 ) {
     /**
     /**
      * An audio type for general media playback usage (i.e. listener-only use cases).
      * An audio type for general media playback usage (i.e. listener-only use cases).
@@ -101,7 +100,7 @@ sealed class AudioType(
             .setUsage(AudioAttributes.USAGE_MEDIA)
             .setUsage(AudioAttributes.USAGE_MEDIA)
             .setContentType(AudioAttributes.CONTENT_TYPE_UNKNOWN)
             .setContentType(AudioAttributes.CONTENT_TYPE_UNKNOWN)
             .build(),
             .build(),
-        AudioManager.STREAM_MUSIC
+        AudioManager.STREAM_MUSIC,
     )
     )
 
 
     /**
     /**
@@ -115,7 +114,7 @@ sealed class AudioType(
             .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
             .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
             .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
             .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
             .build(),
             .build(),
-        AudioManager.STREAM_VOICE_CALL
+        AudioManager.STREAM_VOICE_CALL,
     )
     )
 
 
     /**
     /**
@@ -123,4 +122,4 @@ sealed class AudioType(
      */
      */
     class CustomAudioType(audioMode: Int, audioAttributes: AudioAttributes, audioStreamType: Int) :
     class CustomAudioType(audioMode: Int, audioAttributes: AudioAttributes, audioStreamType: Int) :
         AudioType(audioMode, audioAttributes, audioStreamType)
         AudioType(audioMode, audioAttributes, audioStreamType)
-}
+}

@@ -43,4 +43,4 @@ data class RoomOptions(
     val videoTrackCaptureDefaults: LocalVideoTrackOptions? = null,
     val videoTrackCaptureDefaults: LocalVideoTrackOptions? = null,
     val audioTrackPublishDefaults: AudioTrackPublishDefaults? = null,
     val audioTrackPublishDefaults: AudioTrackPublishDefaults? = null,
     val videoTrackPublishDefaults: VideoTrackPublishDefaults? = null,
     val videoTrackPublishDefaults: VideoTrackPublishDefaults? = null,
-)
+)

@@ -18,4 +18,4 @@ package io.livekit.android
 
 
 object Version {
 object Version {
     const val CLIENT_VERSION = BuildConfig.VERSION_NAME
     const val CLIENT_VERSION = BuildConfig.VERSION_NAME
-}
+}

@@ -106,8 +106,8 @@ constructor(context: Context) : AudioHandler {
                 AudioAttributes.Builder()
                 AudioAttributes.Builder()
                     .setUsage(audioAttributeUsageType)
                     .setUsage(audioAttributeUsageType)
                     .setContentType(audioAttributeContentType)
                     .setContentType(audioAttributeContentType)
-                    .build()
+                    .build(),
             )
             )
             .build()
             .build()
     }
     }
-}
+}

@@ -29,4 +29,4 @@ interface AudioHandler {
      * Called when a room is disconnected.
      * Called when a room is disconnected.
      */
      */
     fun stop()
     fun stop()
-}
+}

@@ -150,14 +150,14 @@ constructor(private val context: Context) : AudioHandler {
                             context = context,
                             context = context,
                             loggingEnabled = loggingEnabled,
                             loggingEnabled = loggingEnabled,
                             audioFocusChangeListener = onAudioFocusChangeListener ?: defaultOnAudioFocusChangeListener,
                             audioFocusChangeListener = onAudioFocusChangeListener ?: defaultOnAudioFocusChangeListener,
-                            preferredDeviceList = preferredDeviceList ?: defaultPreferredDeviceList
+                            preferredDeviceList = preferredDeviceList ?: defaultPreferredDeviceList,
                         )
                         )
                     } else {
                     } else {
                         LegacyAudioSwitch(
                         LegacyAudioSwitch(
                             context = context,
                             context = context,
                             loggingEnabled = loggingEnabled,
                             loggingEnabled = loggingEnabled,
                             audioFocusChangeListener = onAudioFocusChangeListener ?: defaultOnAudioFocusChangeListener,
                             audioFocusChangeListener = onAudioFocusChangeListener ?: defaultOnAudioFocusChangeListener,
-                            preferredDeviceList = preferredDeviceList ?: defaultPreferredDeviceList
+                            preferredDeviceList = preferredDeviceList ?: defaultPreferredDeviceList,
                         )
                         )
                     }
                     }
                 switch.manageAudioFocus = manageAudioFocus
                 switch.manageAudioFocus = manageAudioFocus
@@ -214,8 +214,8 @@ constructor(private val context: Context) : AudioHandler {
                 AudioDevice.BluetoothHeadset::class.java,
                 AudioDevice.BluetoothHeadset::class.java,
                 AudioDevice.WiredHeadset::class.java,
                 AudioDevice.WiredHeadset::class.java,
                 AudioDevice.Earpiece::class.java,
                 AudioDevice.Earpiece::class.java,
-                AudioDevice.Speakerphone::class.java
+                AudioDevice.Speakerphone::class.java,
             )
             )
         }
         }
     }
     }
-}
+}

@@ -29,4 +29,4 @@ constructor() : AudioHandler {
 
 
     override fun stop() {
     override fun stop() {
     }
     }
-}
+}

@@ -37,7 +37,6 @@ fun VideoRenderer(
     modifier: Modifier = Modifier,
     modifier: Modifier = Modifier,
     mirror: Boolean = false,
     mirror: Boolean = false,
 ) {
 ) {
-
     val videoSinkVisibility = remember(room, videoTrack) { ComposeVisibility() }
     val videoSinkVisibility = remember(room, videoTrack) { ComposeVisibility() }
     var boundVideoTrack by remember { mutableStateOf<VideoTrack?>(null) }
     var boundVideoTrack by remember { mutableStateOf<VideoTrack?>(null) }
     var view: TextureViewRenderer? by remember { mutableStateOf(null) }
     var view: TextureViewRenderer? by remember { mutableStateOf(null) }
@@ -93,4 +92,4 @@ fun VideoRenderer(
         modifier = modifier
         modifier = modifier
             .onGloballyPositioned { videoSinkVisibility.onGloballyPositioned(it) },
             .onGloballyPositioned { videoSinkVisibility.onGloballyPositioned(it) },
     )
     )
-}
+}

@@ -42,7 +42,7 @@ object AudioHandlerModule {
 
 
     @Provides
     @Provides
     fun audioOutputAttributes(
     fun audioOutputAttributes(
-        audioType: AudioType
+        audioType: AudioType,
     ): AudioAttributes {
     ): AudioAttributes {
         return audioType.audioAttributes
         return audioType.audioAttributes
     }
     }
@@ -62,4 +62,4 @@ object AudioHandlerModule {
             audioStreamType = audioOutputType.audioStreamType
             audioStreamType = audioOutputType.audioStreamType
         }
         }
     }
     }
-}
+}

@@ -41,4 +41,4 @@ object CoroutinesModule {
     @Provides
     @Provides
     @Named(InjectionNames.DISPATCHER_UNCONFINED)
     @Named(InjectionNames.DISPATCHER_UNCONFINED)
     fun unconfinedDispatcher() = Dispatchers.Unconfined
     fun unconfinedDispatcher() = Dispatchers.Unconfined
-}
+}

@@ -29,7 +29,7 @@ object InjectionNames {
     /**
     /**
      * @see [kotlinx.coroutines.Dispatchers.IO]
      * @see [kotlinx.coroutines.Dispatchers.IO]
      */
      */
-    internal const val DISPATCHER_IO = "dispatcher_io";
+    internal const val DISPATCHER_IO = "dispatcher_io"
 
 
     /**
     /**
      * @see [kotlinx.coroutines.Dispatchers.Main]
      * @see [kotlinx.coroutines.Dispatchers.Main]
@@ -55,4 +55,4 @@ object InjectionNames {
     internal const val OVERRIDE_VIDEO_DECODER_FACTORY = "override_video_decoder_factory"
     internal const val OVERRIDE_VIDEO_DECODER_FACTORY = "override_video_decoder_factory"
     internal const val OVERRIDE_AUDIO_HANDLER = "override_audio_handler"
     internal const val OVERRIDE_AUDIO_HANDLER = "override_audio_handler"
     internal const val OVERRIDE_AUDIO_OUTPUT_TYPE = "override_audio_output_type"
     internal const val OVERRIDE_AUDIO_OUTPUT_TYPE = "override_audio_output_type"
-}
+}

@@ -32,5 +32,4 @@ object JsonFormatModule {
         Json {
         Json {
             ignoreUnknownKeys = true
             ignoreUnknownKeys = true
         }
         }
-
-}
+}

@@ -35,7 +35,7 @@ import javax.inject.Singleton
         OverridesModule::class,
         OverridesModule::class,
         AudioHandlerModule::class,
         AudioHandlerModule::class,
         MemoryModule::class,
         MemoryModule::class,
-    ]
+    ],
 )
 )
 internal interface LiveKitComponent {
 internal interface LiveKitComponent {
 
 
@@ -49,7 +49,7 @@ internal interface LiveKitComponent {
     interface Factory {
     interface Factory {
         fun create(
         fun create(
             @BindsInstance appContext: Context,
             @BindsInstance appContext: Context,
-            overridesModule: OverridesModule
+            overridesModule: OverridesModule,
         ): LiveKitComponent
         ): LiveKitComponent
     }
     }
 }
 }
@@ -60,7 +60,6 @@ internal fun LiveKitComponent.Factory.create(
 ): LiveKitComponent {
 ): LiveKitComponent {
     return create(
     return create(
         appContext = context,
         appContext = context,
-        overridesModule = OverridesModule(overrides)
+        overridesModule = OverridesModule(overrides),
     )
     )
 }
 }
-

@@ -30,4 +30,4 @@ object MemoryModule {
     @Singleton
     @Singleton
     @Provides
     @Provides
     fun closeableManager() = CloseableManager()
     fun closeableManager() = CloseableManager()
-}
+}

@@ -63,5 +63,4 @@ class OverridesModule(private val overrides: LiveKitOverrides) {
     @Provides
     @Provides
     @Named(InjectionNames.OVERRIDE_AUDIO_OUTPUT_TYPE)
     @Named(InjectionNames.OVERRIDE_AUDIO_OUTPUT_TYPE)
     fun audioOutputType() = overrides.audioOptions?.audioOutputType
     fun audioOutputType() = overrides.audioOptions?.audioOutputType
-
 }
 }

@@ -53,24 +53,27 @@ object RTCModule {
         PeerConnectionFactory.initialize(
         PeerConnectionFactory.initialize(
             PeerConnectionFactory.InitializationOptions
             PeerConnectionFactory.InitializationOptions
                 .builder(appContext)
                 .builder(appContext)
-                .setInjectableLogger({ s, severity, s2 ->
-                    if (!LiveKit.enableWebRTCLogging) {
-                        return@setInjectableLogger
-                    }
+                .setInjectableLogger(
+                    { s, severity, s2 ->
+                        if (!LiveKit.enableWebRTCLogging) {
+                            return@setInjectableLogger
+                        }
 
 
-                    val loggingLevel = when (severity) {
-                        Logging.Severity.LS_VERBOSE -> LoggingLevel.VERBOSE
-                        Logging.Severity.LS_INFO -> LoggingLevel.INFO
-                        Logging.Severity.LS_WARNING -> LoggingLevel.WARN
-                        Logging.Severity.LS_ERROR -> LoggingLevel.ERROR
-                        else -> LoggingLevel.OFF
-                    }
+                        val loggingLevel = when (severity) {
+                            Logging.Severity.LS_VERBOSE -> LoggingLevel.VERBOSE
+                            Logging.Severity.LS_INFO -> LoggingLevel.INFO
+                            Logging.Severity.LS_WARNING -> LoggingLevel.WARN
+                            Logging.Severity.LS_ERROR -> LoggingLevel.ERROR
+                            else -> LoggingLevel.OFF
+                        }
 
 
-                    LKLog.log(loggingLevel) {
-                        Timber.log(loggingLevel.toAndroidLogPriority(), "$s2: $s")
-                    }
-                }, Logging.Severity.LS_VERBOSE)
-                .createInitializationOptions()
+                        LKLog.log(loggingLevel) {
+                            Timber.log(loggingLevel.toAndroidLogPriority(), "$s2: $s")
+                        }
+                    },
+                    Logging.Severity.LS_VERBOSE,
+                )
+                .createInitializationOptions(),
         )
         )
         return LibWebrtcInitialization
         return LibWebrtcInitialization
     }
     }
@@ -86,7 +89,7 @@ object RTCModule {
         @Nullable
         @Nullable
         moduleCustomizer: ((builder: JavaAudioDeviceModule.Builder) -> Unit)?,
         moduleCustomizer: ((builder: JavaAudioDeviceModule.Builder) -> Unit)?,
         audioOutputAttributes: AudioAttributes,
         audioOutputAttributes: AudioAttributes,
-        appContext: Context
+        appContext: Context,
     ): AudioDeviceModule {
     ): AudioDeviceModule {
         if (audioDeviceModuleOverride != null) {
         if (audioDeviceModuleOverride != null) {
             return audioDeviceModuleOverride
             return audioDeviceModuleOverride
@@ -100,7 +103,7 @@ object RTCModule {
 
 
             override fun onWebRtcAudioRecordStartError(
             override fun onWebRtcAudioRecordStartError(
                 errorCode: JavaAudioDeviceModule.AudioRecordStartErrorCode?,
                 errorCode: JavaAudioDeviceModule.AudioRecordStartErrorCode?,
-                errorMessage: String?
+                errorMessage: String?,
             ) {
             ) {
                 LKLog.e { "onWebRtcAudioRecordStartError: $errorCode. $errorMessage" }
                 LKLog.e { "onWebRtcAudioRecordStartError: $errorCode. $errorMessage" }
             }
             }
@@ -117,7 +120,7 @@ object RTCModule {
 
 
             override fun onWebRtcAudioTrackStartError(
             override fun onWebRtcAudioTrackStartError(
                 errorCode: JavaAudioDeviceModule.AudioTrackStartErrorCode?,
                 errorCode: JavaAudioDeviceModule.AudioTrackStartErrorCode?,
-                errorMessage: String?
+                errorMessage: String?,
             ) {
             ) {
                 LKLog.e { "onWebRtcAudioTrackStartError: $errorCode. $errorMessage" }
                 LKLog.e { "onWebRtcAudioTrackStartError: $errorCode. $errorMessage" }
             }
             }
@@ -125,7 +128,6 @@ object RTCModule {
             override fun onWebRtcAudioTrackError(errorMessage: String?) {
             override fun onWebRtcAudioTrackError(errorMessage: String?) {
                 LKLog.e { "onWebRtcAudioTrackError: $errorMessage" }
                 LKLog.e { "onWebRtcAudioTrackError: $errorMessage" }
             }
             }
-
         }
         }
         val audioRecordStateCallback: JavaAudioDeviceModule.AudioRecordStateCallback = object :
         val audioRecordStateCallback: JavaAudioDeviceModule.AudioRecordStateCallback = object :
             JavaAudioDeviceModule.AudioRecordStateCallback {
             JavaAudioDeviceModule.AudioRecordStateCallback {
@@ -168,7 +170,9 @@ object RTCModule {
 
 
     @Provides
     @Provides
     @Singleton
     @Singleton
-    fun eglBase(@Singleton memoryManager: CloseableManager): EglBase {
+    fun eglBase(
+        @Singleton memoryManager: CloseableManager,
+    ): EglBase {
         val eglBase = EglBase.create()
         val eglBase = EglBase.create()
         memoryManager.registerResource(eglBase) { eglBase.release() }
         memoryManager.registerResource(eglBase) { eglBase.release() }
 
 
@@ -188,7 +192,7 @@ object RTCModule {
         eglContext: EglBase.Context,
         eglContext: EglBase.Context,
         @Named(InjectionNames.OVERRIDE_VIDEO_ENCODER_FACTORY)
         @Named(InjectionNames.OVERRIDE_VIDEO_ENCODER_FACTORY)
         @Nullable
         @Nullable
-        videoEncoderFactoryOverride: VideoEncoderFactory?
+        videoEncoderFactoryOverride: VideoEncoderFactory?,
     ): VideoEncoderFactory {
     ): VideoEncoderFactory {
         return videoEncoderFactoryOverride ?: if (videoHwAccel) {
         return videoEncoderFactoryOverride ?: if (videoHwAccel) {
             SimulcastVideoEncoderFactoryWrapper(
             SimulcastVideoEncoderFactoryWrapper(
@@ -211,7 +215,7 @@ object RTCModule {
         eglContext: EglBase.Context,
         eglContext: EglBase.Context,
         @Named(InjectionNames.OVERRIDE_VIDEO_DECODER_FACTORY)
         @Named(InjectionNames.OVERRIDE_VIDEO_DECODER_FACTORY)
         @Nullable
         @Nullable
-        videoDecoderFactoryOverride: VideoDecoderFactory?
+        videoDecoderFactoryOverride: VideoDecoderFactory?,
     ): VideoDecoderFactory {
     ): VideoDecoderFactory {
         return videoDecoderFactoryOverride ?: if (videoHwAccel) {
         return videoDecoderFactoryOverride ?: if (videoHwAccel) {
             WrappedVideoDecoderFactory(eglContext)
             WrappedVideoDecoderFactory(eglContext)
@@ -253,4 +257,4 @@ object RTCModule {
 /**
 /**
  * @suppress
  * @suppress
  */
  */
-object LibWebrtcInitialization
+object LibWebrtcInitialization

@@ -39,7 +39,7 @@ object WebModule {
     fun okHttpClient(
     fun okHttpClient(
         @Named(InjectionNames.OVERRIDE_OKHTTP)
         @Named(InjectionNames.OVERRIDE_OKHTTP)
         @Nullable
         @Nullable
-        okHttpClientOverride: OkHttpClient?
+        okHttpClientOverride: OkHttpClient?,
     ): OkHttpClient {
     ): OkHttpClient {
         OkHttpClient.Builder()
         OkHttpClient.Builder()
             .pingInterval(20, TimeUnit.SECONDS)
             .pingInterval(20, TimeUnit.SECONDS)
@@ -58,4 +58,4 @@ object WebModule {
     fun networkInfo(context: Context): NetworkInfo {
     fun networkInfo(context: Context): NetworkInfo {
         return AndroidNetworkInfo(context)
         return AndroidNetworkInfo(context)
     }
     }
-}
+}

+/*
+ * Copyright 2023 LiveKit, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.livekit.android.e2ee
 package io.livekit.android.e2ee
 
 
 import io.livekit.android.events.RoomEvent
 import io.livekit.android.events.RoomEvent
@@ -18,7 +34,7 @@ import org.webrtc.RtpReceiver
 import org.webrtc.RtpSender
 import org.webrtc.RtpSender
 
 
 class E2EEManager
 class E2EEManager
-constructor(keyProvider: KeyProvider)  {
+constructor(keyProvider: KeyProvider) {
     private var room: Room? = null
     private var room: Room? = null
     private var keyProvider: KeyProvider
     private var keyProvider: KeyProvider
     private var frameCryptors = mutableMapOf<String, FrameCryptor>()
     private var frameCryptors = mutableMapOf<String, FrameCryptor>()
@@ -70,10 +86,12 @@ constructor(keyProvider: KeyProvider)  {
             LKLog.i { "Receiver::onFrameCryptionStateChanged: $trackId, state:  $state" }
             LKLog.i { "Receiver::onFrameCryptionStateChanged: $trackId, state:  $state" }
             emitEvent(
             emitEvent(
                 RoomEvent.TrackE2EEStateEvent(
                 RoomEvent.TrackE2EEStateEvent(
-                    room!!, publication.track!!, publication,
+                    room!!,
+                    publication.track!!,
+                    publication,
                     participant,
                     participant,
-                    state = e2eeStateFromFrameCryptoState(state)
-                )
+                    state = e2eeStateFromFrameCryptoState(state),
+                ),
             )
             )
         }
         }
     }
     }
@@ -94,10 +112,12 @@ constructor(keyProvider: KeyProvider)  {
             LKLog.i { "Sender::onFrameCryptionStateChanged: $trackId, state:  $state" }
             LKLog.i { "Sender::onFrameCryptionStateChanged: $trackId, state:  $state" }
             emitEvent(
             emitEvent(
                 RoomEvent.TrackE2EEStateEvent(
                 RoomEvent.TrackE2EEStateEvent(
-                    room!!, publication.track!!, publication,
+                    room!!,
+                    publication.track!!,
+                    publication,
                     participant,
                     participant,
-                    state = e2eeStateFromFrameCryptoState(state)
-                )
+                    state = e2eeStateFromFrameCryptoState(state),
+                ),
             )
             )
         }
         }
     }
     }
@@ -111,18 +131,22 @@ constructor(keyProvider: KeyProvider)  {
             FrameCryptionState.ENCRYPTIONFAILED -> E2EEState.ENCRYPTION_FAILED
             FrameCryptionState.ENCRYPTIONFAILED -> E2EEState.ENCRYPTION_FAILED
             FrameCryptionState.DECRYPTIONFAILED -> E2EEState.DECRYPTION_FAILED
             FrameCryptionState.DECRYPTIONFAILED -> E2EEState.DECRYPTION_FAILED
             FrameCryptionState.INTERNALERROR -> E2EEState.INTERNAL_ERROR
             FrameCryptionState.INTERNALERROR -> E2EEState.INTERNAL_ERROR
-            else -> { E2EEState.INTERNAL_ERROR}
+            else -> { E2EEState.INTERNAL_ERROR }
         }
         }
     }
     }
 
 
-    private fun addRtpSender(sender: RtpSender, participantId: String, trackId: String , kind: String): FrameCryptor {
+    private fun addRtpSender(sender: RtpSender, participantId: String, trackId: String, kind: String): FrameCryptor {
         var pid = "$kind-sender-$participantId-$trackId"
         var pid = "$kind-sender-$participantId-$trackId"
         var frameCryptor = FrameCryptorFactory.createFrameCryptorForRtpSender(
         var frameCryptor = FrameCryptorFactory.createFrameCryptorForRtpSender(
-            sender, pid, algorithm, keyProvider.rtcKeyProvider)
+            sender,
+            pid,
+            algorithm,
+            keyProvider.rtcKeyProvider,
+        )
 
 
         frameCryptors[trackId] = frameCryptor
         frameCryptors[trackId] = frameCryptor
         frameCryptor.setEnabled(enabled)
         frameCryptor.setEnabled(enabled)
-        if(keyProvider.enableSharedKey) {
+        if (keyProvider.enableSharedKey) {
             keyProvider.rtcKeyProvider?.setKey(pid, 0, keyProvider?.sharedKey)
             keyProvider.rtcKeyProvider?.setKey(pid, 0, keyProvider?.sharedKey)
             frameCryptor.setKeyIndex(0)
             frameCryptor.setKeyIndex(0)
         }
         }
@@ -133,12 +157,16 @@ constructor(keyProvider: KeyProvider)  {
     private fun addRtpReceiver(receiver: RtpReceiver, participantId: String, trackId: String, kind: String): FrameCryptor {
     private fun addRtpReceiver(receiver: RtpReceiver, participantId: String, trackId: String, kind: String): FrameCryptor {
         var pid = "$kind-receiver-$participantId-$trackId"
         var pid = "$kind-receiver-$participantId-$trackId"
         var frameCryptor = FrameCryptorFactory.createFrameCryptorForRtpReceiver(
         var frameCryptor = FrameCryptorFactory.createFrameCryptorForRtpReceiver(
-            receiver, pid, algorithm, keyProvider.rtcKeyProvider)
+            receiver,
+            pid,
+            algorithm,
+            keyProvider.rtcKeyProvider,
+        )
 
 
         frameCryptors[trackId] = frameCryptor
         frameCryptors[trackId] = frameCryptor
         frameCryptor.setEnabled(enabled)
         frameCryptor.setEnabled(enabled)
 
 
-        if(keyProvider.enableSharedKey) {
+        if (keyProvider.enableSharedKey) {
             keyProvider.rtcKeyProvider?.setKey(pid, 0, keyProvider?.sharedKey)
             keyProvider.rtcKeyProvider?.setKey(pid, 0, keyProvider?.sharedKey)
             frameCryptor.setKeyIndex(0)
             frameCryptor.setKeyIndex(0)
         }
         }
@@ -156,7 +184,7 @@ constructor(keyProvider: KeyProvider)  {
             var frameCryptor = item.value
             var frameCryptor = item.value
             var participantId = item.key
             var participantId = item.key
             frameCryptor.setEnabled(enabled)
             frameCryptor.setEnabled(enabled)
-            if(keyProvider.enableSharedKey) {
+            if (keyProvider.enableSharedKey) {
                 keyProvider.rtcKeyProvider?.setKey(participantId, 0, keyProvider?.sharedKey)
                 keyProvider.rtcKeyProvider?.setKey(participantId, 0, keyProvider?.sharedKey)
                 frameCryptor.setKeyIndex(0)
                 frameCryptor.setKeyIndex(0)
             }
             }
@@ -169,11 +197,11 @@ constructor(keyProvider: KeyProvider)  {
     fun ratchetKey() {
     fun ratchetKey() {
         for (participantId in frameCryptors.keys) {
         for (participantId in frameCryptors.keys) {
             var newKey = keyProvider.rtcKeyProvider?.ratchetKey(participantId, 0)
             var newKey = keyProvider.rtcKeyProvider?.ratchetKey(participantId, 0)
-            LKLog.d{ "ratchetKey: newKey: $newKey" }
+            LKLog.d { "ratchetKey: newKey: $newKey" }
         }
         }
     }
     }
 
 
-    fun cleanUp()  {
+    fun cleanUp() {
         for (frameCryptor in frameCryptors.values) {
         for (frameCryptor in frameCryptors.values) {
             frameCryptor.dispose()
             frameCryptor.dispose()
         }
         }

+/*
+ * Copyright 2023 LiveKit, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.livekit.android.e2ee
 package io.livekit.android.e2ee
 
 
 import livekit.LivekitModels.Encryption
 import livekit.LivekitModels.Encryption
@@ -15,7 +31,8 @@ constructor(
         defaultRatchetWindowSize,
         defaultRatchetWindowSize,
         true,
         true,
         defaultFaultTolerance,
         defaultFaultTolerance,
-    ), encryptionType: Encryption.Type = Encryption.Type.GCM
+    ),
+    encryptionType: Encryption.Type = Encryption.Type.GCM,
 ) {
 ) {
     var keyProvider: KeyProvider
     var keyProvider: KeyProvider
     var encryptionType: Encryption.Type = Encryption.Type.NONE
     var encryptionType: Encryption.Type = Encryption.Type.NONE

+/*
+ * Copyright 2023 LiveKit, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.livekit.android.e2ee
 package io.livekit.android.e2ee
 
 
 enum class E2EEState {
 enum class E2EEState {
     NEW, // initial state
     NEW, // initial state
-    OK,  // encryption or decryption succeeded
+    OK, // encryption or decryption succeeded
     KEY_RATCHETED, // key ratcheted
     KEY_RATCHETED, // key ratcheted
     MISSING_KEY, // missing key
     MISSING_KEY, // missing key
     ENCRYPTION_FAILED, // encryption failed
     ENCRYPTION_FAILED, // encryption failed
     DECRYPTION_FAILED, // decryption failed
     DECRYPTION_FAILED, // decryption failed
-    INTERNAL_ERROR // internal error
+    INTERNAL_ERROR, // internal error
 }
 }

+/*
+ * Copyright 2023 LiveKit, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.livekit.android.e2ee
 package io.livekit.android.e2ee
 
 
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.LKLog
@@ -5,14 +21,14 @@ import org.webrtc.FrameCryptorFactory
 import org.webrtc.FrameCryptorKeyProvider
 import org.webrtc.FrameCryptorKeyProvider
 
 
 class KeyInfo
 class KeyInfo
-constructor(var participantId: String, var keyIndex: Int, var key: String ) {
+constructor(var participantId: String, var keyIndex: Int, var key: String) {
     override fun toString(): String {
     override fun toString(): String {
         return "KeyInfo(participantId='$participantId', keyIndex=$keyIndex)"
         return "KeyInfo(participantId='$participantId', keyIndex=$keyIndex)"
     }
     }
 }
 }
 
 
- public interface KeyProvider {
-    fun setKey(key: String, participantId: String?, keyIndex: Int?  = 0)
+public interface KeyProvider {
+    fun setKey(key: String, participantId: String?, keyIndex: Int? = 0)
     fun ratchetKey(participantId: String, index: Int): ByteArray
     fun ratchetKey(participantId: String, index: Int): ByteArray
 
 
     val rtcKeyProvider: FrameCryptorKeyProvider
     val rtcKeyProvider: FrameCryptorKeyProvider
@@ -28,7 +44,7 @@ constructor(
     private var uncryptedMagicBytes: String,
     private var uncryptedMagicBytes: String,
     private var ratchetWindowSize: Int,
     private var ratchetWindowSize: Int,
     override var enableSharedKey: Boolean = true,
     override var enableSharedKey: Boolean = true,
-    private var failureTolerance:Int,
+    private var failureTolerance: Int,
 ) :
 ) :
     KeyProvider {
     KeyProvider {
     override var sharedKey: ByteArray? = null
     override var sharedKey: ByteArray? = null
@@ -46,8 +62,8 @@ constructor(
             return
             return
         }
         }
 
 
-        if(participantId == null) {
-            LKLog.d{ "Please provide valid participantId for non-SharedKey mode." }
+        if (participantId == null) {
+            LKLog.d { "Please provide valid participantId for non-SharedKey mode." }
             return
             return
         }
         }
 
 
@@ -72,7 +88,7 @@ constructor(
             ratchetSalt.toByteArray(),
             ratchetSalt.toByteArray(),
             ratchetWindowSize,
             ratchetWindowSize,
             uncryptedMagicBytes.toByteArray(),
             uncryptedMagicBytes.toByteArray(),
-            failureTolerance
+            failureTolerance,
         )
         )
     }
     }
 }
 }

@@ -49,4 +49,4 @@ class BroadcastEventBus<T> : EventListenable<T> {
     }
     }
 
 
     fun readOnly(): EventListenable<T> = this
     fun readOnly(): EventListenable<T> = this
-}
+}

@@ -16,4 +16,4 @@
 
 
 package io.livekit.android.events
 package io.livekit.android.events
 
 
-sealed class Event
+sealed class Event

@@ -24,4 +24,4 @@ interface EventListenable<out T> {
 
 
 suspend inline fun <T> EventListenable<T>.collect(crossinline action: suspend (value: T) -> Unit) {
 suspend inline fun <T> EventListenable<T>.collect(crossinline action: suspend (value: T) -> Unit) {
     events.collect { value -> action(value) }
     events.collect { value -> action(value) }
-}
+}

@@ -58,7 +58,6 @@ sealed class ParticipantEvent(open val participant: Participant) : Event() {
      */
      */
     class TrackUnmuted(participant: Participant, val publication: TrackPublication) : ParticipantEvent(participant)
     class TrackUnmuted(participant: Participant, val publication: TrackPublication) : ParticipantEvent(participant)
 
 
-
     // local participants
     // local participants
     /**
     /**
      * When a new track is published by the local participant.
      * When a new track is published by the local participant.
@@ -113,7 +112,7 @@ sealed class ParticipantEvent(open val participant: Participant) : Event() {
     class TrackUnsubscribed(
     class TrackUnsubscribed(
         override val participant: RemoteParticipant,
         override val participant: RemoteParticipant,
         val track: Track,
         val track: Track,
-        val publication: RemoteTrackPublication
+        val publication: RemoteTrackPublication,
     ) : ParticipantEvent(participant)
     ) : ParticipantEvent(participant)
 
 
     /**
     /**
@@ -122,7 +121,7 @@ sealed class ParticipantEvent(open val participant: Participant) : Event() {
     class DataReceived(
     class DataReceived(
         override val participant: RemoteParticipant,
         override val participant: RemoteParticipant,
         val data: ByteArray,
         val data: ByteArray,
-        val topic: String?
+        val topic: String?,
     ) : ParticipantEvent(participant)
     ) : ParticipantEvent(participant)
 
 
     /**
     /**
@@ -131,17 +130,16 @@ sealed class ParticipantEvent(open val participant: Participant) : Event() {
     class TrackStreamStateChanged(
     class TrackStreamStateChanged(
         override val participant: Participant,
         override val participant: Participant,
         val trackPublication: TrackPublication,
         val trackPublication: TrackPublication,
-        val streamState: Track.StreamState
+        val streamState: Track.StreamState,
     ) : ParticipantEvent(participant)
     ) : ParticipantEvent(participant)
 
 
-
     /**
     /**
      * A remote track's subscription permissions have changed.
      * A remote track's subscription permissions have changed.
      */
      */
     class TrackSubscriptionPermissionChanged(
     class TrackSubscriptionPermissionChanged(
         override val participant: RemoteParticipant,
         override val participant: RemoteParticipant,
         val trackPublication: RemoteTrackPublication,
         val trackPublication: RemoteTrackPublication,
-        val subscriptionAllowed: Boolean
+        val subscriptionAllowed: Boolean,
     ) : ParticipantEvent(participant)
     ) : ParticipantEvent(participant)
 
 
     /**
     /**
@@ -154,4 +152,4 @@ sealed class ParticipantEvent(open val participant: Participant) : Event() {
         val newPermissions: ParticipantPermission?,
         val newPermissions: ParticipantPermission?,
         val oldPermissions: ParticipantPermission?,
         val oldPermissions: ParticipantPermission?,
     ) : ParticipantEvent(participant)
     ) : ParticipantEvent(participant)
-}
+}

@@ -62,7 +62,7 @@ sealed class RoomEvent(val room: Room) : Event() {
     class RoomMetadataChanged(
     class RoomMetadataChanged(
         room: Room,
         room: Room,
         val newMetadata: String?,
         val newMetadata: String?,
-        val prevMetadata: String?
+        val prevMetadata: String?,
     ) : RoomEvent(room)
     ) : RoomEvent(room)
 
 
     // Participant callbacks
     // Participant callbacks
@@ -74,13 +74,13 @@ sealed class RoomEvent(val room: Room) : Event() {
     class ParticipantMetadataChanged(
     class ParticipantMetadataChanged(
         room: Room,
         room: Room,
         val participant: Participant,
         val participant: Participant,
-        val prevMetadata: String?
+        val prevMetadata: String?,
     ) : RoomEvent(room)
     ) : RoomEvent(room)
 
 
     class ParticipantNameChanged(
     class ParticipantNameChanged(
         room: Room,
         room: Room,
         val participant: Participant,
         val participant: Participant,
-        val name: String?
+        val name: String?,
     ) : RoomEvent(room)
     ) : RoomEvent(room)
 
 
     /**
     /**
@@ -119,7 +119,7 @@ sealed class RoomEvent(val room: Room) : Event() {
         room: Room,
         room: Room,
         val track: Track,
         val track: Track,
         val publication: TrackPublication,
         val publication: TrackPublication,
-        val participant: RemoteParticipant
+        val participant: RemoteParticipant,
     ) : RoomEvent(room)
     ) : RoomEvent(room)
 
 
     /**
     /**
@@ -129,7 +129,7 @@ sealed class RoomEvent(val room: Room) : Event() {
         room: Room,
         room: Room,
         val sid: String,
         val sid: String,
         val exception: Exception,
         val exception: Exception,
-        val participant: RemoteParticipant
+        val participant: RemoteParticipant,
     ) : RoomEvent(room)
     ) : RoomEvent(room)
 
 
     /**
     /**
@@ -140,7 +140,7 @@ sealed class RoomEvent(val room: Room) : Event() {
         room: Room,
         room: Room,
         val track: Track,
         val track: Track,
         val publications: TrackPublication,
         val publications: TrackPublication,
-        val participant: RemoteParticipant
+        val participant: RemoteParticipant,
     ) : RoomEvent(room)
     ) : RoomEvent(room)
 
 
     /**
     /**
@@ -149,7 +149,7 @@ sealed class RoomEvent(val room: Room) : Event() {
     class TrackStreamStateChanged(
     class TrackStreamStateChanged(
         room: Room,
         room: Room,
         val trackPublication: TrackPublication,
         val trackPublication: TrackPublication,
-        val streamState: Track.StreamState
+        val streamState: Track.StreamState,
     ) : RoomEvent(room)
     ) : RoomEvent(room)
 
 
     /**
     /**
@@ -159,7 +159,7 @@ sealed class RoomEvent(val room: Room) : Event() {
         room: Room,
         room: Room,
         val participant: RemoteParticipant,
         val participant: RemoteParticipant,
         val trackPublication: RemoteTrackPublication,
         val trackPublication: RemoteTrackPublication,
-        val subscriptionAllowed: Boolean
+        val subscriptionAllowed: Boolean,
     ) : RoomEvent(room)
     ) : RoomEvent(room)
 
 
     /**
     /**
@@ -200,14 +200,14 @@ sealed class RoomEvent(val room: Room) : Event() {
     class RecordingStatusChanged(room: Room, isRecording: Boolean) : RoomEvent(room)
     class RecordingStatusChanged(room: Room, isRecording: Boolean) : RoomEvent(room)
 
 
     /**
     /**
-    * The E2EE state of a track has changed.
-    */
+     * The E2EE state of a track has changed.
+     */
     class TrackE2EEStateEvent(
     class TrackE2EEStateEvent(
         room: Room,
         room: Room,
         val track: Track,
         val track: Track,
         val publication: TrackPublication,
         val publication: TrackPublication,
         val participant: Participant,
         val participant: Participant,
-        var state: E2EEState
+        var state: E2EEState,
     ) : RoomEvent(room)
     ) : RoomEvent(room)
 }
 }
 
 
@@ -219,7 +219,7 @@ enum class DisconnectReason {
     PARTICIPANT_REMOVED,
     PARTICIPANT_REMOVED,
     ROOM_DELETED,
     ROOM_DELETED,
     STATE_MISMATCH,
     STATE_MISMATCH,
-    JOIN_FAILURE;
+    JOIN_FAILURE,
 }
 }
 
 
 fun LivekitModels.DisconnectReason?.convert(): DisconnectReason {
 fun LivekitModels.DisconnectReason?.convert(): DisconnectReason {
@@ -233,6 +233,7 @@ fun LivekitModels.DisconnectReason?.convert(): DisconnectReason {
         LivekitModels.DisconnectReason.JOIN_FAILURE -> DisconnectReason.JOIN_FAILURE
         LivekitModels.DisconnectReason.JOIN_FAILURE -> DisconnectReason.JOIN_FAILURE
         LivekitModels.DisconnectReason.UNKNOWN_REASON,
         LivekitModels.DisconnectReason.UNKNOWN_REASON,
         LivekitModels.DisconnectReason.UNRECOGNIZED,
         LivekitModels.DisconnectReason.UNRECOGNIZED,
-        null -> DisconnectReason.UNKNOWN_REASON
+        null,
+        -> DisconnectReason.UNKNOWN_REASON
     }
     }
-}
+}

@@ -22,4 +22,4 @@ sealed class TrackEvent(val track: Track) : Event() {
     class VisibilityChanged(track: Track, val isVisible: Boolean) : TrackEvent(track)
     class VisibilityChanged(track: Track, val isVisible: Boolean) : TrackEvent(track)
     class VideoDimensionsChanged(track: Track, val newDimensions: Track.Dimensions) : TrackEvent(track)
     class VideoDimensionsChanged(track: Track, val newDimensions: Track.Dimensions) : TrackEvent(track)
     class StreamStateChanged(track: Track, val streamState: Track.StreamState) : TrackEvent(track)
     class StreamStateChanged(track: Track, val streamState: Track.StreamState) : TrackEvent(track)
-}
+}

@@ -57,4 +57,4 @@ class CloseableManager : Closeable {
         resources.values.forEach { it.close() }
         resources.values.forEach { it.close() }
         resources.clear()
         resources.clear()
     }
     }
-}
+}

@@ -28,4 +28,4 @@ internal class SurfaceTextureHelperCloser(private val surfaceTextureHelper: Surf
             surfaceTextureHelper.dispose()
             surfaceTextureHelper.dispose()
         }
         }
     }
     }
-}
+}

@@ -31,4 +31,4 @@ open class SurfaceViewRenderer : SurfaceViewRenderer, ViewVisibility.Notifier {
         super.onVisibilityChanged(changedView, visibility)
         super.onVisibilityChanged(changedView, visibility)
         viewVisibility?.recalculate()
         viewVisibility?.recalculate()
     }
     }
-}
+}

@@ -23,12 +23,16 @@ import org.webrtc.*
 import org.webrtc.RendererCommon.*
 import org.webrtc.RendererCommon.*
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.CountDownLatch
 
 
-
 /**
 /**
  * Display the video stream on a TextureView.
  * Display the video stream on a TextureView.
  */
  */
-open class TextureViewRenderer : TextureView, SurfaceHolder.Callback, TextureView.SurfaceTextureListener, VideoSink,
-    RendererEvents, ViewVisibility.Notifier {
+open class TextureViewRenderer :
+    TextureView,
+    SurfaceHolder.Callback,
+    TextureView.SurfaceTextureListener,
+    VideoSink,
+    RendererEvents,
+    ViewVisibility.Notifier {
     // Cached resource name.
     // Cached resource name.
     private val resourceName: String
     private val resourceName: String
     private val videoLayoutMeasure = VideoLayoutMeasure()
     private val videoLayoutMeasure = VideoLayoutMeasure()
@@ -68,6 +72,7 @@ open class TextureViewRenderer : TextureView, SurfaceHolder.Callback, TextureVie
      * `drawer`. It is allowed to call init() to reinitialize the renderer after a previous
      * `drawer`. It is allowed to call init() to reinitialize the renderer after a previous
      * init()/release() cycle.
      * init()/release() cycle.
      */
      */
+
     /**
     /**
      * Initialize this class, sharing resources with `sharedContext`. It is allowed to call init() to
      * Initialize this class, sharing resources with `sharedContext`. It is allowed to call init() to
      * reinitialize the renderer after a previous init()/release() cycle.
      * reinitialize the renderer after a previous init()/release() cycle.
@@ -75,14 +80,15 @@ open class TextureViewRenderer : TextureView, SurfaceHolder.Callback, TextureVie
     @JvmOverloads
     @JvmOverloads
     fun init(
     fun init(
         sharedContext: EglBase.Context?,
         sharedContext: EglBase.Context?,
-        rendererEvents: RendererEvents?, configAttributes: IntArray? = EglBase.CONFIG_PLAIN,
-        drawer: GlDrawer? = GlRectDrawer()
+        rendererEvents: RendererEvents?,
+        configAttributes: IntArray? = EglBase.CONFIG_PLAIN,
+        drawer: GlDrawer? = GlRectDrawer(),
     ) {
     ) {
         ThreadUtils.checkIsOnMainThread()
         ThreadUtils.checkIsOnMainThread()
         this.rendererEvents = rendererEvents
         this.rendererEvents = rendererEvents
         rotatedFrameWidth = 0
         rotatedFrameWidth = 0
         rotatedFrameHeight = 0
         rotatedFrameHeight = 0
-        eglRenderer.init(sharedContext, this /* rendererEvents */, configAttributes, drawer)
+        eglRenderer.init(sharedContext, this, configAttributes, drawer)
     }
     }
 
 
     /**
     /**
@@ -105,7 +111,9 @@ open class TextureViewRenderer : TextureView, SurfaceHolder.Callback, TextureVie
      * @param drawer   Custom drawer to use for this frame listener.
      * @param drawer   Custom drawer to use for this frame listener.
      */
      */
     fun addFrameListener(
     fun addFrameListener(
-        listener: EglRenderer.FrameListener?, scale: Float, drawerParam: GlDrawer?
+        listener: EglRenderer.FrameListener?,
+        scale: Float,
+        drawerParam: GlDrawer?,
     ) {
     ) {
         eglRenderer.addFrameListener(listener, scale, drawerParam)
         eglRenderer.addFrameListener(listener, scale, drawerParam)
     }
     }
@@ -155,12 +163,12 @@ open class TextureViewRenderer : TextureView, SurfaceHolder.Callback, TextureVie
 
 
     fun setScalingType(
     fun setScalingType(
         scalingTypeMatchOrientation: ScalingType?,
         scalingTypeMatchOrientation: ScalingType?,
-        scalingTypeMismatchOrientation: ScalingType?
+        scalingTypeMismatchOrientation: ScalingType?,
     ) {
     ) {
         ThreadUtils.checkIsOnMainThread()
         ThreadUtils.checkIsOnMainThread()
         videoLayoutMeasure.setScalingType(
         videoLayoutMeasure.setScalingType(
             scalingTypeMatchOrientation,
             scalingTypeMatchOrientation,
-            scalingTypeMismatchOrientation
+            scalingTypeMismatchOrientation,
         )
         )
         requestLayout()
         requestLayout()
     }
     }
@@ -221,14 +229,14 @@ open class TextureViewRenderer : TextureView, SurfaceHolder.Callback, TextureVie
             val width = Math.min(width, drawnFrameWidth)
             val width = Math.min(width, drawnFrameWidth)
             val height = Math.min(height, drawnFrameHeight)
             val height = Math.min(height, drawnFrameHeight)
             logD(
             logD(
-                "updateSurfaceSize. Layout size: " + getWidth() + "x" + getHeight() + ", frame size: "
-                        + rotatedFrameWidth + "x" + rotatedFrameHeight + ", requested surface size: " + width
-                        + "x" + height + ", old surface size: " + surfaceWidth + "x" + surfaceHeight
+                "updateSurfaceSize. Layout size: " + getWidth() + "x" + getHeight() + ", frame size: " +
+                    rotatedFrameWidth + "x" + rotatedFrameHeight + ", requested surface size: " + width +
+                    "x" + height + ", old surface size: " + surfaceWidth + "x" + surfaceHeight,
             )
             )
             if (width != surfaceWidth || height != surfaceHeight) {
             if (width != surfaceWidth || height != surfaceHeight) {
                 surfaceWidth = width
                 surfaceWidth = width
                 surfaceHeight = height
                 surfaceHeight = height
-                adjustAspectRatio(surfaceWidth, surfaceHeight);
+                adjustAspectRatio(surfaceWidth, surfaceHeight)
             }
             }
         } else {
         } else {
             surfaceHeight = 0
             surfaceHeight = 0
@@ -257,8 +265,8 @@ open class TextureViewRenderer : TextureView, SurfaceHolder.Callback, TextureVie
         val xoff = (viewWidth - newWidth) / 2
         val xoff = (viewWidth - newWidth) / 2
         val yoff = (viewHeight - newHeight) / 2
         val yoff = (viewHeight - newHeight) / 2
         logD(
         logD(
-            "video=" + videoWidth + "x" + videoHeight + " view=" + viewWidth + "x" + viewHeight
-                    + " newView=" + newWidth + "x" + newHeight + " off=" + xoff + "," + yoff
+            "video=" + videoWidth + "x" + videoHeight + " view=" + viewWidth + "x" + viewHeight +
+                " newView=" + newWidth + "x" + newHeight + " off=" + xoff + "," + yoff,
         )
         )
         val txform = Matrix()
         val txform = Matrix()
         getTransform(txform)
         getTransform(txform)
@@ -360,4 +368,4 @@ open class TextureViewRenderer : TextureView, SurfaceHolder.Callback, TextureVie
         super.onVisibilityChanged(changedView, visibility)
         super.onVisibilityChanged(changedView, visibility)
         viewVisibility?.recalculate()
         viewVisibility?.recalculate()
     }
     }
-}
+}

@@ -20,5 +20,5 @@ enum class ConnectionState {
     CONNECTING,
     CONNECTING,
     CONNECTED,
     CONNECTED,
     DISCONNECTED,
     DISCONNECTED,
-    RECONNECTING;
-}
+    RECONNECTING,
+}

@@ -31,4 +31,4 @@ constructor() {
     var audioTrackPublishDefaults: AudioTrackPublishDefaults = AudioTrackPublishDefaults()
     var audioTrackPublishDefaults: AudioTrackPublishDefaults = AudioTrackPublishDefaults()
     var videoTrackCaptureDefaults: LocalVideoTrackOptions = LocalVideoTrackOptions()
     var videoTrackCaptureDefaults: LocalVideoTrackOptions = LocalVideoTrackOptions()
     var videoTrackPublishDefaults: VideoTrackPublishDefaults = VideoTrackPublishDefaults()
     var videoTrackPublishDefaults: VideoTrackPublishDefaults = VideoTrackPublishDefaults()
-}
+}

@@ -27,7 +27,7 @@ object DeviceManager {
 
 
     enum class Kind {
     enum class Kind {
         // Only camera input currently, audio input/output only has one option atm.
         // Only camera input currently, audio input/output only has one option atm.
-        CAMERA;
+        CAMERA,
     }
     }
 
 
     private val defaultDevices = mutableMapOf<Kind, String>()
     private val defaultDevices = mutableMapOf<Kind, String>()
@@ -44,19 +44,22 @@ object DeviceManager {
 
 
         hasSetupListeners = true
         hasSetupListeners = true
         val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
         val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
-        cameraManager.registerAvailabilityCallback(object : CameraManager.AvailabilityCallback() {
-            override fun onCameraAvailable(cameraId: String) {
-                notifyListeners(Kind.CAMERA)
-            }
+        cameraManager.registerAvailabilityCallback(
+            object : CameraManager.AvailabilityCallback() {
+                override fun onCameraAvailable(cameraId: String) {
+                    notifyListeners(Kind.CAMERA)
+                }
 
 
-            override fun onCameraUnavailable(cameraId: String) {
-                notifyListeners(Kind.CAMERA)
-            }
+                override fun onCameraUnavailable(cameraId: String) {
+                    notifyListeners(Kind.CAMERA)
+                }
 
 
-            override fun onCameraAccessPrioritiesChanged() {
-                notifyListeners(Kind.CAMERA)
-            }
-        }, Handler(Looper.getMainLooper()))
+                override fun onCameraAccessPrioritiesChanged() {
+                    notifyListeners(Kind.CAMERA)
+                }
+            },
+            Handler(Looper.getMainLooper()),
+        )
     }
     }
 
 
     fun getDefaultDevice(kind: Kind): String? {
     fun getDefaultDevice(kind: Kind): String? {
@@ -89,7 +92,7 @@ object DeviceManager {
 
 
     fun registerOnDeviceAvailabilityChange(
     fun registerOnDeviceAvailabilityChange(
         kind: Kind,
         kind: Kind,
-        listener: OnDeviceAvailabilityChangeListener
+        listener: OnDeviceAvailabilityChangeListener,
     ) {
     ) {
         if (listeners[kind] == null) {
         if (listeners[kind] == null) {
             listeners[kind] = mutableListOf()
             listeners[kind] = mutableListOf()
@@ -99,7 +102,7 @@ object DeviceManager {
 
 
     fun unregisterOnDeviceAvailabilityChange(
     fun unregisterOnDeviceAvailabilityChange(
         kind: Kind,
         kind: Kind,
-        listener: OnDeviceAvailabilityChangeListener
+        listener: OnDeviceAvailabilityChangeListener,
     ) {
     ) {
         listeners[kind]?.remove(listener)
         listeners[kind]?.remove(listener)
     }
     }
@@ -113,4 +116,4 @@ object DeviceManager {
     interface OnDeviceAvailabilityChangeListener {
     interface OnDeviceAvailabilityChangeListener {
         fun onDeviceAvailabilityChanged(kind: Kind)
         fun onDeviceAvailabilityChanged(kind: Kind)
     }
     }
-}
+}

@@ -22,4 +22,4 @@ import kotlinx.serialization.Serializable
  * @suppress
  * @suppress
  */
  */
 @Serializable
 @Serializable
-data class IceCandidateJSON(val candidate: String, val sdpMLineIndex: Int, val sdpMid: String?)
+data class IceCandidateJSON(val candidate: String, val sdpMLineIndex: Int, val sdpMid: String?)

@@ -45,12 +45,12 @@ constructor(
     @Assisted private val listener: Listener?,
     @Assisted private val listener: Listener?,
     @Named(InjectionNames.DISPATCHER_IO)
     @Named(InjectionNames.DISPATCHER_IO)
     private val ioDispatcher: CoroutineDispatcher,
     private val ioDispatcher: CoroutineDispatcher,
-    connectionFactory: PeerConnectionFactory
+    connectionFactory: PeerConnectionFactory,
 ) {
 ) {
     private val coroutineScope = CoroutineScope(ioDispatcher + SupervisorJob())
     private val coroutineScope = CoroutineScope(ioDispatcher + SupervisorJob())
     internal val peerConnection: PeerConnection = connectionFactory.createPeerConnection(
     internal val peerConnection: PeerConnection = connectionFactory.createPeerConnection(
         config,
         config,
-        pcObserver
+        pcObserver,
     ) ?: throw IllegalStateException("peer connection creation failed?")
     ) ?: throw IllegalStateException("peer connection creation failed?")
     private val pendingCandidates = mutableListOf<IceCandidate>()
     private val pendingCandidates = mutableListOf<IceCandidate>()
     private var restartingIce: Boolean = false
     private var restartingIce: Boolean = false
@@ -76,7 +76,6 @@ constructor(
     }
     }
 
 
     suspend fun setRemoteDescription(sd: SessionDescription): Either<Unit, String?> {
     suspend fun setRemoteDescription(sd: SessionDescription): Either<Unit, String?> {
-
         val result = peerConnection.setRemoteDescription(sd)
         val result = peerConnection.setRemoteDescription(sd)
         if (result is Either.Left) {
         if (result is Either.Left) {
             mutex.withLock {
             mutex.withLock {
@@ -145,7 +144,6 @@ constructor(
         listener?.onOffer(sdpOffer)
         listener?.onOffer(sdpOffer)
     }
     }
 
 
-
     fun prepareForIceRestart() {
     fun prepareForIceRestart() {
         restartingIce = true
         restartingIce = true
     }
     }
@@ -163,7 +161,7 @@ constructor(
         fun create(
         fun create(
             config: PeerConnection.RTCConfiguration,
             config: PeerConnection.RTCConfiguration,
             pcObserver: PeerConnection.Observer,
             pcObserver: PeerConnection.Observer,
-            listener: Listener?
+            listener: Listener?,
         ): PeerConnectionTransport
         ): PeerConnectionTransport
     }
     }
-}
+}

@@ -85,5 +85,4 @@ class PublisherTransportObserver(
 
 
     override fun onAddTrack(p0: RtpReceiver?, p1: Array<out MediaStream>?) {
     override fun onAddTrack(p0: RtpReceiver?, p1: Array<out MediaStream>?) {
     }
     }
-
-}
+}

@@ -21,7 +21,6 @@ import com.google.protobuf.ByteString
 import io.livekit.android.ConnectOptions
 import io.livekit.android.ConnectOptions
 import io.livekit.android.RoomOptions
 import io.livekit.android.RoomOptions
 import io.livekit.android.dagger.InjectionNames
 import io.livekit.android.dagger.InjectionNames
-import io.livekit.android.e2ee.E2EEOptions
 import io.livekit.android.events.DisconnectReason
 import io.livekit.android.events.DisconnectReason
 import io.livekit.android.events.convert
 import io.livekit.android.events.convert
 import io.livekit.android.room.participant.ParticipantTrackPermission
 import io.livekit.android.room.participant.ParticipantTrackPermission
@@ -39,7 +38,6 @@ import io.livekit.android.webrtc.toProtoSessionDescription
 import kotlinx.coroutines.*
 import kotlinx.coroutines.*
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.Mutex
 import livekit.LivekitModels
 import livekit.LivekitModels
-import livekit.LivekitModels.Encryption
 import livekit.LivekitRtc
 import livekit.LivekitRtc
 import livekit.LivekitRtc.JoinResponse
 import livekit.LivekitRtc.JoinResponse
 import livekit.LivekitRtc.ReconnectResponse
 import livekit.LivekitRtc.ReconnectResponse
@@ -150,7 +148,7 @@ internal constructor(
         url: String,
         url: String,
         token: String,
         token: String,
         options: ConnectOptions,
         options: ConnectOptions,
-        roomOptions: RoomOptions
+        roomOptions: RoomOptions,
     ): JoinResponse {
     ): JoinResponse {
         coroutineScope.close()
         coroutineScope.close()
         coroutineScope = CloseableCoroutineScope(SupervisorJob() + ioDispatcher)
         coroutineScope = CloseableCoroutineScope(SupervisorJob() + ioDispatcher)
@@ -165,7 +163,7 @@ internal constructor(
         url: String,
         url: String,
         token: String,
         token: String,
         options: ConnectOptions,
         options: ConnectOptions,
-        roomOptions: RoomOptions
+        roomOptions: RoomOptions,
     ): JoinResponse {
     ): JoinResponse {
         val joinResponse = client.join(url, token, options, roomOptions)
         val joinResponse = client.join(url, token, options, roomOptions)
         listener?.onJoinResponse(joinResponse)
         listener?.onJoinResponse(joinResponse)
@@ -248,7 +246,7 @@ internal constructor(
         reliableInit.ordered = true
         reliableInit.ordered = true
         reliableDataChannel = publisher.peerConnection.createDataChannel(
         reliableDataChannel = publisher.peerConnection.createDataChannel(
             RELIABLE_DATA_CHANNEL_LABEL,
             RELIABLE_DATA_CHANNEL_LABEL,
-            reliableInit
+            reliableInit,
         )
         )
         reliableDataChannel!!.registerObserver(this)
         reliableDataChannel!!.registerObserver(this)
         val lossyInit = DataChannel.Init()
         val lossyInit = DataChannel.Init()
@@ -256,7 +254,7 @@ internal constructor(
         lossyInit.maxRetransmits = 0
         lossyInit.maxRetransmits = 0
         lossyDataChannel = publisher.peerConnection.createDataChannel(
         lossyDataChannel = publisher.peerConnection.createDataChannel(
             LOSSY_DATA_CHANNEL_LABEL,
             LOSSY_DATA_CHANNEL_LABEL,
-            lossyInit
+            lossyInit,
         )
         )
         lossyDataChannel!!.registerObserver(this)
         lossyDataChannel!!.registerObserver(this)
     }
     }
@@ -268,7 +266,7 @@ internal constructor(
         cid: String,
         cid: String,
         name: String,
         name: String,
         kind: LivekitModels.TrackType,
         kind: LivekitModels.TrackType,
-        builder: LivekitRtc.AddTrackRequest.Builder = LivekitRtc.AddTrackRequest.newBuilder()
+        builder: LivekitRtc.AddTrackRequest.Builder = LivekitRtc.AddTrackRequest.newBuilder(),
     ): LivekitModels.TrackInfo {
     ): LivekitModels.TrackInfo {
         if (pendingTrackResolvers[cid] != null) {
         if (pendingTrackResolvers[cid] != null) {
             throw TrackException.DuplicateTrackException("Track with same ID $cid has already been published!")
             throw TrackException.DuplicateTrackException("Track with same ID $cid has already been published!")
@@ -282,7 +280,7 @@ internal constructor(
 
 
     fun updateSubscriptionPermissions(
     fun updateSubscriptionPermissions(
         allParticipants: Boolean,
         allParticipants: Boolean,
-        participantTrackPermissions: List<ParticipantTrackPermission>
+        participantTrackPermissions: List<ParticipantTrackPermission>,
     ) {
     ) {
         client.sendUpdateSubscriptionPermissions(allParticipants, participantTrackPermissions)
         client.sendUpdateSubscriptionPermissions(allParticipants, participantTrackPermissions)
     }
     }
@@ -348,7 +346,6 @@ internal constructor(
         val forceFullReconnect = fullReconnectOnNext
         val forceFullReconnect = fullReconnectOnNext
         fullReconnectOnNext = false
         fullReconnectOnNext = false
         val job = coroutineScope.launch {
         val job = coroutineScope.launch {
-
             connectionState = ConnectionState.RECONNECTING
             connectionState = ConnectionState.RECONNECTING
             listener?.onEngineReconnecting()
             listener?.onEngineReconnecting()
 
 
@@ -498,7 +495,6 @@ internal constructor(
             this.negotiatePublisher()
             this.negotiatePublisher()
         }
         }
 
 
-
         val targetChannel = dataChannelForKind(kind) ?: throw IllegalArgumentException("Unknown data packet kind!")
         val targetChannel = dataChannelForKind(kind) ?: throw IllegalArgumentException("Unknown data packet kind!")
         if (targetChannel.state() == DataChannel.State.OPEN) {
         if (targetChannel.state() == DataChannel.State.OPEN) {
             return
             return
@@ -529,21 +525,21 @@ internal constructor(
                 add(
                 add(
                     MediaConstraints.KeyValuePair(
                     MediaConstraints.KeyValuePair(
                         MediaConstraintKeys.OFFER_TO_RECV_AUDIO,
                         MediaConstraintKeys.OFFER_TO_RECV_AUDIO,
-                        MediaConstraintKeys.FALSE
-                    )
+                        MediaConstraintKeys.FALSE,
+                    ),
                 )
                 )
                 add(
                 add(
                     MediaConstraints.KeyValuePair(
                     MediaConstraints.KeyValuePair(
                         MediaConstraintKeys.OFFER_TO_RECV_VIDEO,
                         MediaConstraintKeys.OFFER_TO_RECV_VIDEO,
-                        MediaConstraintKeys.FALSE
-                    )
+                        MediaConstraintKeys.FALSE,
+                    ),
                 )
                 )
                 if (connectionState == ConnectionState.RECONNECTING) {
                 if (connectionState == ConnectionState.RECONNECTING) {
                     add(
                     add(
                         MediaConstraints.KeyValuePair(
                         MediaConstraints.KeyValuePair(
                             MediaConstraintKeys.ICE_RESTART,
                             MediaConstraintKeys.ICE_RESTART,
-                            MediaConstraintKeys.TRUE
-                        )
+                            MediaConstraintKeys.TRUE,
+                        ),
                     )
                     )
                 }
                 }
             }
             }
@@ -552,9 +548,8 @@ internal constructor(
 
 
     private fun makeRTCConfig(
     private fun makeRTCConfig(
         serverResponse: Either<JoinResponse, ReconnectResponse>,
         serverResponse: Either<JoinResponse, ReconnectResponse>,
-        connectOptions: ConnectOptions
+        connectOptions: ConnectOptions,
     ): RTCConfiguration {
     ): RTCConfiguration {
-
         // Convert protobuf ice servers
         // Convert protobuf ice servers
         val serverIceServers = run {
         val serverIceServers = run {
             val servers = mutableListOf<PeerConnection.IceServer>()
             val servers = mutableListOf<PeerConnection.IceServer>()
@@ -664,7 +659,7 @@ internal constructor(
         }
         }
     }
     }
 
 
-    //---------------------------------- SignalClient.Listener --------------------------------------//
+    // ---------------------------------- SignalClient.Listener --------------------------------------//
 
 
     override fun onAnswer(sessionDescription: SessionDescription) {
     override fun onAnswer(sessionDescription: SessionDescription) {
         LKLog.v { "received server answer: ${sessionDescription.type}, ${publisher.peerConnection.signalingState()}" }
         LKLog.v { "received server answer: ${sessionDescription.type}, ${publisher.peerConnection.signalingState()}" }
@@ -686,8 +681,10 @@ internal constructor(
         LKLog.v { "received server offer: ${sessionDescription.type}, ${subscriber.peerConnection.signalingState()}" }
         LKLog.v { "received server offer: ${sessionDescription.type}, ${subscriber.peerConnection.signalingState()}" }
         coroutineScope.launch {
         coroutineScope.launch {
             run<Unit> {
             run<Unit> {
-                when (val outcome =
-                    subscriber.setRemoteDescription(sessionDescription)) {
+                when (
+                    val outcome =
+                        subscriber.setRemoteDescription(sessionDescription)
+                ) {
                     is Either.Right -> {
                     is Either.Right -> {
                         LKLog.e { "error setting remote description for answer: ${outcome.value} " }
                         LKLog.e { "error setting remote description for answer: ${outcome.value} " }
                         return@launch
                         return@launch
@@ -821,7 +818,7 @@ internal constructor(
         listener?.onLocalTrackUnpublished(trackUnpublished)
         listener?.onLocalTrackUnpublished(trackUnpublished)
     }
     }
 
 
-    //--------------------------------- DataChannel.Observer ------------------------------------//
+    // --------------------------------- DataChannel.Observer ------------------------------------//
 
 
     override fun onBufferedAmountChange(previousAmount: Long) {
     override fun onBufferedAmountChange(previousAmount: Long) {
     }
     }
@@ -844,7 +841,8 @@ internal constructor(
             }
             }
 
 
             LivekitModels.DataPacket.ValueCase.VALUE_NOT_SET,
             LivekitModels.DataPacket.ValueCase.VALUE_NOT_SET,
-            null -> {
+            null,
+            -> {
                 LKLog.v { "invalid value for data packet" }
                 LKLog.v { "invalid value for data packet" }
             }
             }
         }
         }
@@ -852,7 +850,7 @@ internal constructor(
 
 
     fun sendSyncState(
     fun sendSyncState(
         subscription: LivekitRtc.UpdateSubscription,
         subscription: LivekitRtc.UpdateSubscription,
-        publishedTracks: List<LivekitRtc.TrackPublishedResponse>
+        publishedTracks: List<LivekitRtc.TrackPublishedResponse>,
     ) {
     ) {
         val answer = subscriber.peerConnection.localDescription?.toProtoSessionDescription()
         val answer = subscriber.peerConnection.localDescription?.toProtoSessionDescription()
 
 
@@ -894,7 +892,7 @@ internal constructor(
 enum class ReconnectType {
 enum class ReconnectType {
     DEFAULT,
     DEFAULT,
     FORCE_SOFT_RECONNECT,
     FORCE_SOFT_RECONNECT,
-    FORCE_FULL_RECONNECT;
+    FORCE_FULL_RECONNECT,
 }
 }
 
 
 internal fun LivekitRtc.ICEServer.toWebrtc() = PeerConnection.IceServer.builder(urlsList)
 internal fun LivekitRtc.ICEServer.toWebrtc() = PeerConnection.IceServer.builder(urlsList)
@@ -902,4 +900,4 @@ internal fun LivekitRtc.ICEServer.toWebrtc() = PeerConnection.IceServer.builder(
     .setPassword(credential ?: "")
     .setPassword(credential ?: "")
     .setTlsAlpnProtocols(emptyList())
     .setTlsAlpnProtocols(emptyList())
     .setTlsEllipticCurves(emptyList())
     .setTlsEllipticCurves(emptyList())
-    .createIceServer()
+    .createIceServer()

@@ -80,7 +80,7 @@ constructor(
         CONNECTING,
         CONNECTING,
         CONNECTED,
         CONNECTED,
         DISCONNECTED,
         DISCONNECTED,
-        RECONNECTING;
+        RECONNECTING,
     }
     }
 
 
     /**
     /**
@@ -90,7 +90,7 @@ constructor(
         SPEAKER_UPDATE,
         SPEAKER_UPDATE,
         NODE_FAILURE,
         NODE_FAILURE,
         MIGRATION,
         MIGRATION,
-        SERVER_LEAVE;
+        SERVER_LEAVE,
     }
     }
 
 
     @JvmInline
     @JvmInline
@@ -224,7 +224,7 @@ constructor(
                             room = this@Room,
                             room = this@Room,
                             publication = it.publication,
                             publication = it.publication,
                             participant = it.participant,
                             participant = it.participant,
-                        )
+                        ),
                     )
                     )
 
 
                     is ParticipantEvent.ParticipantPermissionsChanged -> emitWhenConnected(
                     is ParticipantEvent.ParticipantPermissionsChanged -> emitWhenConnected(
@@ -233,7 +233,7 @@ constructor(
                             participant = it.participant,
                             participant = it.participant,
                             newPermissions = it.newPermissions,
                             newPermissions = it.newPermissions,
                             oldPermissions = it.oldPermissions,
                             oldPermissions = it.oldPermissions,
-                        )
+                        ),
                     )
                     )
 
 
                     is ParticipantEvent.MetadataChanged -> {
                     is ParticipantEvent.MetadataChanged -> {
@@ -242,8 +242,8 @@ constructor(
                             RoomEvent.ParticipantMetadataChanged(
                             RoomEvent.ParticipantMetadataChanged(
                                 this@Room,
                                 this@Room,
                                 it.participant,
                                 it.participant,
-                                it.prevMetadata
-                            )
+                                it.prevMetadata,
+                            ),
                         )
                         )
                     }
                     }
 
 
@@ -252,13 +252,13 @@ constructor(
                             RoomEvent.ParticipantNameChanged(
                             RoomEvent.ParticipantNameChanged(
                                 this@Room,
                                 this@Room,
                                 it.participant,
                                 it.participant,
-                                it.name
-                            )
+                                it.name,
+                            ),
                         )
                         )
                     }
                     }
 
 
                     else -> {
                     else -> {
-                        /* do nothing */
+                        // do nothing
                     }
                     }
                 }
                 }
             }
             }
@@ -267,9 +267,9 @@ constructor(
         state = State.CONNECTING
         state = State.CONNECTING
         connectOptions = options
         connectOptions = options
 
 
-        if(roomOptions.e2eeOptions != null) {
+        if (roomOptions.e2eeOptions != null) {
             e2eeManager = E2EEManager(roomOptions!!.e2eeOptions!!.keyProvider)
             e2eeManager = E2EEManager(roomOptions!!.e2eeOptions!!.keyProvider)
-            e2eeManager!!.setup(this, {event ->
+            e2eeManager!!.setup(this, { event ->
                 coroutineScope.launch {
                 coroutineScope.launch {
                     emitWhenConnected(event)
                     emitWhenConnected(event)
                 }
                 }
@@ -316,7 +316,6 @@ constructor(
      * @suppress
      * @suppress
      */
      */
     override fun onJoinResponse(response: LivekitRtc.JoinResponse) {
     override fun onJoinResponse(response: LivekitRtc.JoinResponse) {
-
         LKLog.i { "Connected to server, server version: ${response.serverVersion}, client version: ${Version.CLIENT_VERSION}" }
         LKLog.i { "Connected to server, server version: ${response.serverVersion}, client version: ${Version.CLIENT_VERSION}" }
 
 
         sid = Sid(response.room.sid)
         sid = Sid(response.room.sid)
@@ -365,7 +364,7 @@ constructor(
     @Synchronized
     @Synchronized
     private fun getOrCreateRemoteParticipant(
     private fun getOrCreateRemoteParticipant(
         sid: String,
         sid: String,
-        info: LivekitModels.ParticipantInfo? = null
+        info: LivekitModels.ParticipantInfo? = null,
     ): RemoteParticipant {
     ): RemoteParticipant {
         var participant = remoteParticipants[sid]
         var participant = remoteParticipants[sid]
         if (participant != null) {
         if (participant != null) {
@@ -389,7 +388,7 @@ constructor(
                                     room = this@Room,
                                     room = this@Room,
                                     publication = it.publication,
                                     publication = it.publication,
                                     participant = it.participant,
                                     participant = it.participant,
-                                )
+                                ),
                             )
                             )
                         }
                         }
                     }
                     }
@@ -398,8 +397,8 @@ constructor(
                         RoomEvent.TrackStreamStateChanged(
                         RoomEvent.TrackStreamStateChanged(
                             this@Room,
                             this@Room,
                             it.trackPublication,
                             it.trackPublication,
-                            it.streamState
-                        )
+                            it.streamState,
+                        ),
                     )
                     )
 
 
                     is ParticipantEvent.TrackSubscriptionPermissionChanged -> eventBus.postEvent(
                     is ParticipantEvent.TrackSubscriptionPermissionChanged -> eventBus.postEvent(
@@ -407,8 +406,8 @@ constructor(
                             this@Room,
                             this@Room,
                             it.participant,
                             it.participant,
                             it.trackPublication,
                             it.trackPublication,
-                            it.subscriptionAllowed
-                        )
+                            it.subscriptionAllowed,
+                        ),
                     )
                     )
 
 
                     is ParticipantEvent.MetadataChanged -> {
                     is ParticipantEvent.MetadataChanged -> {
@@ -417,8 +416,8 @@ constructor(
                             RoomEvent.ParticipantMetadataChanged(
                             RoomEvent.ParticipantMetadataChanged(
                                 this@Room,
                                 this@Room,
                                 it.participant,
                                 it.participant,
-                                it.prevMetadata
-                            )
+                                it.prevMetadata,
+                            ),
                         )
                         )
                     }
                     }
 
 
@@ -428,7 +427,7 @@ constructor(
                                 this@Room,
                                 this@Room,
                                 it.participant,
                                 it.participant,
                                 it.name,
                                 it.name,
-                            )
+                            ),
                         )
                         )
                     }
                     }
 
 
@@ -438,11 +437,11 @@ constructor(
                             participant = it.participant,
                             participant = it.participant,
                             newPermissions = it.newPermissions,
                             newPermissions = it.newPermissions,
                             oldPermissions = it.oldPermissions,
                             oldPermissions = it.oldPermissions,
-                        )
+                        ),
                     )
                     )
 
 
                     else -> {
                     else -> {
-                        /* do nothing */
+                        // do nothing
                     }
                     }
                 }
                 }
             }
             }
@@ -529,7 +528,7 @@ constructor(
     private fun cleanupRoom() {
     private fun cleanupRoom() {
         e2eeManager?.cleanUp()
         e2eeManager?.cleanUp()
         localParticipant.cleanup()
         localParticipant.cleanup()
-        remoteParticipants.keys.toMutableSet()  // copy keys to avoid concurrent modifications.
+        remoteParticipants.keys.toMutableSet() // copy keys to avoid concurrent modifications.
             .forEach { sid -> handleParticipantDisconnect(sid) }
             .forEach { sid -> handleParticipantDisconnect(sid) }
 
 
         sid = null
         sid = null
@@ -632,7 +631,7 @@ constructor(
         fun create(context: Context): Room
         fun create(context: Context): Room
     }
     }
 
 
-    //------------------------------------- NetworkCallback -------------------------------------//
+    // ------------------------------------- NetworkCallback -------------------------------------//
     private val networkCallback = object : ConnectivityManager.NetworkCallback() {
     private val networkCallback = object : ConnectivityManager.NetworkCallback() {
         /**
         /**
          * @suppress
          * @suppress
@@ -656,7 +655,7 @@ constructor(
         }
         }
     }
     }
 
 
-    //----------------------------------- RTCEngine.Listener ------------------------------------//
+    // ----------------------------------- RTCEngine.Listener ------------------------------------//
 
 
     /**
     /**
      * @suppress
      * @suppress
@@ -703,7 +702,7 @@ constructor(
             trackSid!!,
             trackSid!!,
             autoManageVideo = adaptiveStream,
             autoManageVideo = adaptiveStream,
             statsGetter = statsGetter,
             statsGetter = statsGetter,
-            receiver = receiver
+            receiver = receiver,
         )
         )
     }
     }
 
 
@@ -864,7 +863,7 @@ constructor(
      */
      */
     override fun onFullReconnecting() {
     override fun onFullReconnecting() {
         localParticipant.prepareForFullReconnect()
         localParticipant.prepareForFullReconnect()
-        remoteParticipants.keys.toMutableSet()  // copy keys to avoid concurrent modifications.
+        remoteParticipants.keys.toMutableSet() // copy keys to avoid concurrent modifications.
             .forEach { sid -> handleParticipantDisconnect(sid) }
             .forEach { sid -> handleParticipantDisconnect(sid) }
     }
     }
 
 
@@ -895,7 +894,7 @@ constructor(
         localParticipant.handleLocalTrackUnpublished(trackUnpublished)
         localParticipant.handleLocalTrackUnpublished(trackUnpublished)
     }
     }
 
 
-    //------------------------------- ParticipantListener --------------------------------//
+    // ------------------------------- ParticipantListener --------------------------------//
     /**
     /**
      * This is called for both Local and Remote participants
      * This is called for both Local and Remote participants
      * @suppress
      * @suppress
@@ -928,11 +927,12 @@ constructor(
      */
      */
     override fun onTrackPublished(publication: LocalTrackPublication, participant: LocalParticipant) {
     override fun onTrackPublished(publication: LocalTrackPublication, participant: LocalParticipant) {
         listener?.onTrackPublished(publication, participant, this)
         listener?.onTrackPublished(publication, participant, this)
-        if(e2eeManager != null) {
+        if (e2eeManager != null) {
             e2eeManager!!.addPublishedTrack(publication.track!!, publication, participant, this)
             e2eeManager!!.addPublishedTrack(publication.track!!, publication, participant, this)
         }
         }
         eventBus.postEvent(RoomEvent.TrackPublished(this, publication, participant), coroutineScope)
         eventBus.postEvent(RoomEvent.TrackPublished(this, publication, participant), coroutineScope)
     }
     }
+
     /**
     /**
      * @suppress
      * @suppress
      */
      */
@@ -946,7 +946,7 @@ constructor(
      */
      */
     override fun onTrackSubscribed(track: Track, publication: RemoteTrackPublication, participant: RemoteParticipant) {
     override fun onTrackSubscribed(track: Track, publication: RemoteTrackPublication, participant: RemoteParticipant) {
         listener?.onTrackSubscribed(track, publication, participant, this)
         listener?.onTrackSubscribed(track, publication, participant, this)
-        if(e2eeManager != null) {
+        if (e2eeManager != null) {
             e2eeManager!!.addSubscribedTrack(track, publication, participant, this)
             e2eeManager!!.addSubscribedTrack(track, publication, participant, this)
         }
         }
         eventBus.postEvent(RoomEvent.TrackSubscribed(this, track, publication, participant), coroutineScope)
         eventBus.postEvent(RoomEvent.TrackSubscribed(this, track, publication, participant), coroutineScope)
@@ -958,7 +958,7 @@ constructor(
     override fun onTrackSubscriptionFailed(
     override fun onTrackSubscriptionFailed(
         sid: String,
         sid: String,
         exception: Exception,
         exception: Exception,
-        participant: RemoteParticipant
+        participant: RemoteParticipant,
     ) {
     ) {
         listener?.onTrackSubscriptionFailed(sid, exception, participant, this)
         listener?.onTrackSubscriptionFailed(sid, exception, participant, this)
         eventBus.postEvent(RoomEvent.TrackSubscriptionFailed(this, sid, exception, participant), coroutineScope)
         eventBus.postEvent(RoomEvent.TrackSubscriptionFailed(this, sid, exception, participant), coroutineScope)
@@ -970,7 +970,7 @@ constructor(
     override fun onTrackUnsubscribed(
     override fun onTrackUnsubscribed(
         track: Track,
         track: Track,
         publication: RemoteTrackPublication,
         publication: RemoteTrackPublication,
-        participant: RemoteParticipant
+        participant: RemoteParticipant,
     ) {
     ) {
         listener?.onTrackUnsubscribed(track, publication, participant, this)
         listener?.onTrackUnsubscribed(track, publication, participant, this)
         eventBus.postEvent(RoomEvent.TrackUnsubscribed(this, track, publication, participant), coroutineScope)
         eventBus.postEvent(RoomEvent.TrackUnsubscribed(this, track, publication, participant), coroutineScope)
@@ -982,7 +982,7 @@ constructor(
     fun initVideoRenderer(viewRenderer: SurfaceViewRenderer) {
     fun initVideoRenderer(viewRenderer: SurfaceViewRenderer) {
         viewRenderer.init(eglBase.eglBaseContext, null)
         viewRenderer.init(eglBase.eglBaseContext, null)
         viewRenderer.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT)
         viewRenderer.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT)
-        viewRenderer.setEnableHardwareScaler(false /* enabled */)
+        viewRenderer.setEnableHardwareScaler(false)
     }
     }
 
 
     /**
     /**
@@ -991,7 +991,7 @@ constructor(
     fun initVideoRenderer(viewRenderer: TextureViewRenderer) {
     fun initVideoRenderer(viewRenderer: TextureViewRenderer) {
         viewRenderer.init(eglBase.eglBaseContext, null)
         viewRenderer.init(eglBase.eglBaseContext, null)
         viewRenderer.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT)
         viewRenderer.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT)
-        viewRenderer.setEnableHardwareScaler(false /* enabled */)
+        viewRenderer.setEnableHardwareScaler(false)
     }
     }
 
 
     private suspend fun emitWhenConnected(event: RoomEvent) {
     private suspend fun emitWhenConnected(event: RoomEvent) {
@@ -1171,4 +1171,4 @@ internal fun unpackStreamId(packed: String): Pair<String, String?> {
         return Pair(packed, null)
         return Pair(packed, null)
     }
     }
     return Pair(parts[0], parts[1])
     return Pair(parts[0], parts[1])
-}
+}

@@ -78,9 +78,11 @@ constructor(
     // join will always return a JoinResponse.
     // join will always return a JoinResponse.
     // reconnect will return a ReconnectResponse or a Unit if a different response was received.
     // reconnect will return a ReconnectResponse or a Unit if a different response was received.
     private var joinContinuation: CancellableContinuation<
     private var joinContinuation: CancellableContinuation<
-            Either<
-                    JoinResponse,
-                    Either<ReconnectResponse, Unit>>>? = null
+        Either<
+            JoinResponse,
+            Either<ReconnectResponse, Unit>,
+            >,
+        >? = null
     private lateinit var coroutineScope: CloseableCoroutineScope
     private lateinit var coroutineScope: CloseableCoroutineScope
 
 
     private val requestFlowJobLock = Object()
     private val requestFlowJobLock = Object()
@@ -121,7 +123,7 @@ constructor(
                     reconnect = true
                     reconnect = true
                     this.participantSid = participantSid
                     this.participantSid = participantSid
                 },
                 },
-            lastRoomOptions ?: RoomOptions()
+            lastRoomOptions ?: RoomOptions(),
         )
         )
         return (reconnectResponse as Either.Right).value
         return (reconnectResponse as Either.Right).value
     }
     }
@@ -130,7 +132,7 @@ constructor(
         url: String,
         url: String,
         token: String,
         token: String,
         options: ConnectOptions,
         options: ConnectOptions,
-        roomOptions: RoomOptions
+        roomOptions: RoomOptions,
     ): Either<JoinResponse, Either<ReconnectResponse, Unit>> {
     ): Either<JoinResponse, Either<ReconnectResponse, Unit>> {
         // Clean up any pre-existing connection.
         // Clean up any pre-existing connection.
         close(reason = "Starting new connection")
         close(reason = "Starting new connection")
@@ -160,9 +162,8 @@ constructor(
         token: String,
         token: String,
         clientInfo: LivekitModels.ClientInfo,
         clientInfo: LivekitModels.ClientInfo,
         options: ConnectOptions,
         options: ConnectOptions,
-        roomOptions: RoomOptions
+        roomOptions: RoomOptions,
     ): String {
     ): String {
-
         val queryParams = mutableListOf<Pair<String, String>>()
         val queryParams = mutableListOf<Pair<String, String>>()
         queryParams.add(CONNECT_QUERY_TOKEN to token)
         queryParams.add(CONNECT_QUERY_TOKEN to token)
         queryParams.add(CONNECT_QUERY_PROTOCOL to options.protocolVersion.value.toString())
         queryParams.add(CONNECT_QUERY_PROTOCOL to options.protocolVersion.value.toString())
@@ -234,7 +235,7 @@ constructor(
         startRequestQueue()
         startRequestQueue()
     }
     }
 
 
-    //--------------------------------- WebSocket Listener --------------------------------------//
+    // --------------------------------- WebSocket Listener --------------------------------------//
     override fun onMessage(webSocket: WebSocket, text: String) {
     override fun onMessage(webSocket: WebSocket, text: String) {
         LKLog.w { "received JSON message, unsupported in this version." }
         LKLog.w { "received JSON message, unsupported in this version." }
     }
     }
@@ -291,7 +292,7 @@ constructor(
             // Handle websocket closure here.
             // Handle websocket closure here.
             handleWebSocketClose(
             handleWebSocketClose(
                 reason = reason ?: response?.toString() ?: t.localizedMessage ?: "websocket failure",
                 reason = reason ?: response?.toString() ?: t.localizedMessage ?: "websocket failure",
-                code = response?.code ?: CLOSE_REASON_WEBSOCKET_FAILURE
+                code = response?.code ?: CLOSE_REASON_WEBSOCKET_FAILURE,
             )
             )
         }
         }
     }
     }
@@ -306,7 +307,7 @@ constructor(
         pongJob?.cancel()
         pongJob?.cancel()
     }
     }
 
 
-    //------------------------------- End WebSocket Listener ------------------------------------//
+    // ------------------------------- End WebSocket Listener ------------------------------------//
 
 
     private fun fromProtoSessionDescription(sd: LivekitRtc.SessionDescription): SessionDescription {
     private fun fromProtoSessionDescription(sd: LivekitRtc.SessionDescription): SessionDescription {
         val rtcSdpType = when (sd.type) {
         val rtcSdpType = when (sd.type) {
@@ -340,7 +341,7 @@ constructor(
         val iceCandidateJSON = IceCandidateJSON(
         val iceCandidateJSON = IceCandidateJSON(
             candidate = candidate.sdp,
             candidate = candidate.sdp,
             sdpMid = candidate.sdpMid,
             sdpMid = candidate.sdpMid,
-            sdpMLineIndex = candidate.sdpMLineIndex
+            sdpMLineIndex = candidate.sdpMLineIndex,
         )
         )
 
 
         val trickleRequest = LivekitRtc.TrickleRequest.newBuilder()
         val trickleRequest = LivekitRtc.TrickleRequest.newBuilder()
@@ -375,7 +376,7 @@ constructor(
         cid: String,
         cid: String,
         name: String,
         name: String,
         type: LivekitModels.TrackType,
         type: LivekitModels.TrackType,
-        builder: LivekitRtc.AddTrackRequest.Builder = LivekitRtc.AddTrackRequest.newBuilder()
+        builder: LivekitRtc.AddTrackRequest.Builder = LivekitRtc.AddTrackRequest.newBuilder(),
     ) {
     ) {
         var encryptionType = lastRoomOptions?.e2eeOptions?.encryptionType ?: LivekitModels.Encryption.Type.NONE
         var encryptionType = lastRoomOptions?.e2eeOptions?.encryptionType ?: LivekitModels.Encryption.Type.NONE
         val addTrackRequest = builder
         val addTrackRequest = builder
@@ -442,7 +443,7 @@ constructor(
 
 
     fun sendUpdateSubscriptionPermissions(
     fun sendUpdateSubscriptionPermissions(
         allParticipants: Boolean,
         allParticipants: Boolean,
-        participantTrackPermissions: List<ParticipantTrackPermission>
+        participantTrackPermissions: List<ParticipantTrackPermission>,
     ) {
     ) {
         val update = LivekitRtc.SubscriptionPermission.newBuilder()
         val update = LivekitRtc.SubscriptionPermission.newBuilder()
             .setAllParticipants(allParticipants)
             .setAllParticipants(allParticipants)
@@ -580,7 +581,7 @@ constructor(
                 val iceCandidate = IceCandidate(
                 val iceCandidate = IceCandidate(
                     iceCandidateJson.sdpMid,
                     iceCandidateJson.sdpMid,
                     iceCandidateJson.sdpMLineIndex,
                     iceCandidateJson.sdpMLineIndex,
-                    iceCandidateJson.candidate
+                    iceCandidateJson.candidate,
                 )
                 )
                 listener?.onTrickle(iceCandidate, response.trickle.target)
                 listener?.onTrickle(iceCandidate, response.trickle.target)
             }
             }
@@ -658,7 +659,8 @@ constructor(
             }
             }
 
 
             LivekitRtc.SignalResponse.MessageCase.MESSAGE_NOT_SET,
             LivekitRtc.SignalResponse.MessageCase.MESSAGE_NOT_SET,
-            null -> {
+            null,
+            -> {
                 LKLog.v { "empty messageCase!" }
                 LKLog.v { "empty messageCase!" }
             }
             }
         }
         }
@@ -721,7 +723,7 @@ constructor(
         joinContinuation?.cancel()
         joinContinuation?.cancel()
         joinContinuation = null
         joinContinuation = null
         // TODO: support calling this from connect without wiping any queued requests.
         // TODO: support calling this from connect without wiping any queued requests.
-        //requestFlow.resetReplayCache()
+        // requestFlow.resetReplayCache()
         responseFlow.resetReplayCache()
         responseFlow.resetReplayCache()
         lastUrl = null
         lastUrl = null
         lastOptions = null
         lastOptions = null
@@ -804,4 +806,4 @@ enum class ProtocolVersion(val value: Int) {
     v7(7),
     v7(7),
     v8(8),
     v8(8),
     v9(9),
     v9(9),
-}
+}

@@ -96,5 +96,4 @@ class SubscriberTransportObserver(
 
 
     override fun onRenegotiationNeeded() {
     override fun onRenegotiationNeeded() {
     }
     }
-
-}
+}

@@ -144,7 +144,7 @@ internal constructor(
             name,
             name,
             LocalVideoTrackOptions(isScreencast = true),
             LocalVideoTrackOptions(isScreencast = true),
             eglBase,
             eglBase,
-            screencastVideoTrackFactory
+            screencastVideoTrackFactory,
         )
         )
     }
     }
 
 
@@ -171,7 +171,7 @@ internal constructor(
      */
      */
     suspend fun setScreenShareEnabled(
     suspend fun setScreenShareEnabled(
         enabled: Boolean,
         enabled: Boolean,
-        mediaProjectionPermissionResultData: Intent? = null
+        mediaProjectionPermissionResultData: Intent? = null,
     ) {
     ) {
         setTrackEnabled(Track.Source.SCREEN_SHARE, enabled, mediaProjectionPermissionResultData)
         setTrackEnabled(Track.Source.SCREEN_SHARE, enabled, mediaProjectionPermissionResultData)
     }
     }
@@ -179,7 +179,7 @@ internal constructor(
     private suspend fun setTrackEnabled(
     private suspend fun setTrackEnabled(
         source: Track.Source,
         source: Track.Source,
         enabled: Boolean,
         enabled: Boolean,
-        mediaProjectionPermissionResultData: Intent? = null
+        mediaProjectionPermissionResultData: Intent? = null,
 
 
     ) {
     ) {
         val pub = getTrackPublication(source)
         val pub = getTrackPublication(source)
@@ -238,16 +238,16 @@ internal constructor(
         track: LocalAudioTrack,
         track: LocalAudioTrack,
         options: AudioTrackPublishOptions = AudioTrackPublishOptions(
         options: AudioTrackPublishOptions = AudioTrackPublishOptions(
             null,
             null,
-            audioTrackPublishDefaults
+            audioTrackPublishDefaults,
         ),
         ),
-        publishListener: PublishListener? = null
+        publishListener: PublishListener? = null,
     ) {
     ) {
         val encodings = listOf(
         val encodings = listOf(
             RtpParameters.Encoding(null, true, null).apply {
             RtpParameters.Encoding(null, true, null).apply {
                 if (options.audioBitrate != null && options.audioBitrate > 0) {
                 if (options.audioBitrate != null && options.audioBitrate > 0) {
                     maxBitrateBps = options.audioBitrate
                     maxBitrateBps = options.audioBitrate
                 }
                 }
-            }
+            },
         )
         )
         publishTrackImpl(
         publishTrackImpl(
             track = track,
             track = track,
@@ -264,9 +264,8 @@ internal constructor(
     suspend fun publishVideoTrack(
     suspend fun publishVideoTrack(
         track: LocalVideoTrack,
         track: LocalVideoTrack,
         options: VideoTrackPublishOptions = VideoTrackPublishOptions(null, videoTrackPublishDefaults),
         options: VideoTrackPublishOptions = VideoTrackPublishOptions(null, videoTrackPublishDefaults),
-        publishListener: PublishListener? = null
+        publishListener: PublishListener? = null,
     ) {
     ) {
-
         val encodings = computeVideoEncodings(track.dimensions, options)
         val encodings = computeVideoEncodings(track.dimensions, options)
         val videoLayers =
         val videoLayers =
             EncodingUtils.videoLayersFromEncodings(track.dimensions.width, track.dimensions.height, encodings)
             EncodingUtils.videoLayersFromEncodings(track.dimensions.width, track.dimensions.height, encodings)
@@ -285,11 +284,10 @@ internal constructor(
                 addAllLayers(videoLayers)
                 addAllLayers(videoLayers)
             },
             },
             encodings = encodings,
             encodings = encodings,
-            publishListener = publishListener
+            publishListener = publishListener,
         )
         )
     }
     }
 
 
-
     /**
     /**
      * @return true if the track publish was successful.
      * @return true if the track publish was successful.
      */
      */
@@ -298,7 +296,7 @@ internal constructor(
         options: TrackPublishOptions,
         options: TrackPublishOptions,
         requestConfig: LivekitRtc.AddTrackRequest.Builder.() -> Unit,
         requestConfig: LivekitRtc.AddTrackRequest.Builder.() -> Unit,
         encodings: List<RtpParameters.Encoding> = emptyList(),
         encodings: List<RtpParameters.Encoding> = emptyList(),
-        publishListener: PublishListener? = null
+        publishListener: PublishListener? = null,
     ): Boolean {
     ): Boolean {
         if (localTrackPublications.any { it.track == track }) {
         if (localTrackPublications.any { it.track == track }) {
             publishListener?.onPublishFailure(TrackException.PublishException("Track has already been published"))
             publishListener?.onPublishFailure(TrackException.PublishException("Track has already been published"))
@@ -313,12 +311,12 @@ internal constructor(
             cid = cid,
             cid = cid,
             name = track.name,
             name = track.name,
             kind = track.kind.toProto(),
             kind = track.kind.toProto(),
-            builder = builder
+            builder = builder,
         )
         )
         val transInit = RtpTransceiver.RtpTransceiverInit(
         val transInit = RtpTransceiver.RtpTransceiverInit(
             RtpTransceiver.RtpTransceiverDirection.SEND_ONLY,
             RtpTransceiver.RtpTransceiverDirection.SEND_ONLY,
             listOf(this.sid),
             listOf(this.sid),
-            encodings
+            encodings,
         )
         )
         val transceiver = engine.publisher.peerConnection.addTransceiver(track.rtcTrack, transInit)
         val transceiver = engine.publisher.peerConnection.addTransceiver(track.rtcTrack, transInit)
 
 
@@ -393,7 +391,7 @@ internal constructor(
 
 
     private fun computeVideoEncodings(
     private fun computeVideoEncodings(
         dimensions: Track.Dimensions,
         dimensions: Track.Dimensions,
-        options: VideoTrackPublishOptions
+        options: VideoTrackPublishOptions,
     ): List<RtpParameters.Encoding> {
     ): List<RtpParameters.Encoding> {
         val (width, height) = dimensions
         val (width, height) = dimensions
         var encoding = options.videoEncoding
         var encoding = options.videoEncoding
@@ -410,7 +408,6 @@ internal constructor(
 
 
         val encodings = mutableListOf<RtpParameters.Encoding>()
         val encodings = mutableListOf<RtpParameters.Encoding>()
         if (simulcast) {
         if (simulcast) {
-
             val presets = EncodingUtils.presetsForResolution(width, height)
             val presets = EncodingUtils.presetsForResolution(width, height)
             val midPreset = presets[1]
             val midPreset = presets[1]
             val lowPreset = presets[0]
             val lowPreset = presets[0]
@@ -456,7 +453,6 @@ internal constructor(
         return encodings
         return encodings
     }
     }
 
 
-
     /**
     /**
      * Control who can subscribe to LocalParticipant's published tracks.
      * Control who can subscribe to LocalParticipant's published tracks.
      *
      *
@@ -476,7 +472,7 @@ internal constructor(
      */
      */
     fun setTrackSubscriptionPermissions(
     fun setTrackSubscriptionPermissions(
         allParticipantsAllowed: Boolean,
         allParticipantsAllowed: Boolean,
-        participantTrackPermissions: List<ParticipantTrackPermission> = emptyList()
+        participantTrackPermissions: List<ParticipantTrackPermission> = emptyList(),
     ) {
     ) {
         engine.updateSubscriptionPermissions(allParticipantsAllowed, participantTrackPermissions)
         engine.updateSubscriptionPermissions(allParticipantsAllowed, participantTrackPermissions)
     }
     }
@@ -605,7 +601,7 @@ internal constructor(
         for (quality in qualities) {
         for (quality in qualities) {
             val rid = EncodingUtils.ridForVideoQuality(quality.quality) ?: continue
             val rid = EncodingUtils.ridForVideoQuality(quality.quality) ?: continue
             val encoding = encodings.firstOrNull { it.rid == rid }
             val encoding = encodings.firstOrNull { it.rid == rid }
-            // use low quality layer settings for non-simulcasted streams
+                // use low quality layer settings for non-simulcasted streams
                 ?: encodings.takeIf { it.size == 1 && quality.quality == LivekitModels.VideoQuality.LOW }?.first()
                 ?: encodings.takeIf { it.size == 1 && quality.quality == LivekitModels.VideoQuality.LOW }?.first()
                 ?: continue
                 ?: continue
             if (encoding.active != quality.enabled) {
             if (encoding.active != quality.enabled) {
@@ -732,7 +728,7 @@ data class VideoTrackPublishOptions(
 ) : BaseVideoTrackPublishOptions(), TrackPublishOptions {
 ) : BaseVideoTrackPublishOptions(), TrackPublishOptions {
     constructor(
     constructor(
         name: String? = null,
         name: String? = null,
-        base: BaseVideoTrackPublishOptions
+        base: BaseVideoTrackPublishOptions,
     ) : this(
     ) : this(
         name,
         name,
         base.videoEncoding,
         base.videoEncoding,
@@ -748,21 +744,21 @@ abstract class BaseAudioTrackPublishOptions {
 
 
 data class AudioTrackPublishDefaults(
 data class AudioTrackPublishDefaults(
     override val audioBitrate: Int? = 20_000,
     override val audioBitrate: Int? = 20_000,
-    override val dtx: Boolean = true
+    override val dtx: Boolean = true,
 ) : BaseAudioTrackPublishOptions()
 ) : BaseAudioTrackPublishOptions()
 
 
 data class AudioTrackPublishOptions(
 data class AudioTrackPublishOptions(
     override val name: String? = null,
     override val name: String? = null,
     override val audioBitrate: Int? = null,
     override val audioBitrate: Int? = null,
-    override val dtx: Boolean = true
+    override val dtx: Boolean = true,
 ) : BaseAudioTrackPublishOptions(), TrackPublishOptions {
 ) : BaseAudioTrackPublishOptions(), TrackPublishOptions {
     constructor(
     constructor(
         name: String? = null,
         name: String? = null,
-        base: BaseAudioTrackPublishOptions
+        base: BaseAudioTrackPublishOptions,
     ) : this(
     ) : this(
         name,
         name,
         base.audioBitrate,
         base.audioBitrate,
-        base.dtx
+        base.dtx,
     )
     )
 }
 }
 
 
@@ -785,7 +781,7 @@ data class ParticipantTrackPermission(
     /**
     /**
      * The list of track ids that the target participant can subscribe to.
      * The list of track ids that the target participant can subscribe to.
      */
      */
-    val allowedTrackSids: List<String> = emptyList()
+    val allowedTrackSids: List<String> = emptyList(),
 ) {
 ) {
     init {
     init {
         if (participantIdentity == null && participantSid == null) {
         if (participantIdentity == null && participantSid == null) {
@@ -806,11 +802,11 @@ data class ParticipantTrackPermission(
 sealed class PublishRecord() {
 sealed class PublishRecord() {
     data class AudioTrackPublishRecord(
     data class AudioTrackPublishRecord(
         val track: LocalAudioTrack,
         val track: LocalAudioTrack,
-        val options: AudioTrackPublishOptions
+        val options: AudioTrackPublishOptions,
     )
     )
 
 
     data class VideoTrackPublishRecord(
     data class VideoTrackPublishRecord(
         val track: LocalVideoTrack,
         val track: LocalVideoTrack,
-        val options: VideoTrackPublishOptions
+        val options: VideoTrackPublishOptions,
     )
     )
-}
+}

@@ -127,9 +127,9 @@ open class Participant(
                 ParticipantEvent.ParticipantPermissionsChanged(
                 ParticipantEvent.ParticipantPermissionsChanged(
                     this,
                     this,
                     newPermissions,
                     newPermissions,
-                    oldPermissions
+                    oldPermissions,
                 ),
                 ),
-                scope
+                scope,
             )
             )
         }
         }
     }
     }
@@ -191,7 +191,7 @@ open class Participant(
                             // Re-emit when track changes
                             // Re-emit when track changes
                             trackPublication::track.flow
                             trackPublication::track.flow
                                 .map { trackPublication to trackPublication.track }
                                 .map { trackPublication to trackPublication.track }
-                        }
+                        },
                 ) { trackPubs ->
                 ) { trackPubs ->
                     trackPubs.toList()
                     trackPubs.toList()
                 }
                 }
@@ -208,7 +208,7 @@ open class Participant(
         stateFlow = ::tracks.flow
         stateFlow = ::tracks.flow
             .map { it.filterValues { publication -> publication.kind == Track.Kind.AUDIO } }
             .map { it.filterValues { publication -> publication.kind == Track.Kind.AUDIO } }
             .trackUpdateFlow()
             .trackUpdateFlow()
-            .stateIn(delegateScope, SharingStarted.Eagerly, emptyList())
+            .stateIn(delegateScope, SharingStarted.Eagerly, emptyList()),
     )
     )
 
 
     /**
     /**
@@ -220,7 +220,7 @@ open class Participant(
         stateFlow = ::tracks.flow
         stateFlow = ::tracks.flow
             .map { it.filterValues { publication -> publication.kind == Track.Kind.VIDEO } }
             .map { it.filterValues { publication -> publication.kind == Track.Kind.VIDEO } }
             .trackUpdateFlow()
             .trackUpdateFlow()
-            .stateIn(delegateScope, SharingStarted.Eagerly, emptyList())
+            .stateIn(delegateScope, SharingStarted.Eagerly, emptyList()),
     )
     )
 
 
     /**
     /**
@@ -340,7 +340,7 @@ open class Participant(
         val trackPublication = tracks[trackEvent.track.sid] ?: return
         val trackPublication = tracks[trackEvent.track.sid] ?: return
         eventBus.postEvent(
         eventBus.postEvent(
             ParticipantEvent.TrackStreamStateChanged(this, trackPublication, trackEvent.streamState),
             ParticipantEvent.TrackStreamStateChanged(this, trackPublication, trackEvent.streamState),
-            scope
+            scope,
         )
         )
     }
     }
 
 
@@ -392,7 +392,6 @@ interface ParticipantListener {
      */
      */
     fun onTrackUnmuted(publication: TrackPublication, participant: Participant) {}
     fun onTrackUnmuted(publication: TrackPublication, participant: Participant) {}
 
 
-
     // local participants
     // local participants
     /**
     /**
      * When a new track is published by the local participant.
      * When a new track is published by the local participant.
@@ -428,7 +427,7 @@ interface ParticipantListener {
     fun onTrackSubscriptionFailed(
     fun onTrackSubscriptionFailed(
         sid: String,
         sid: String,
         exception: Exception,
         exception: Exception,
-        participant: RemoteParticipant
+        participant: RemoteParticipant,
     ) {
     ) {
     }
     }
 
 
@@ -439,7 +438,7 @@ interface ParticipantListener {
     fun onTrackUnsubscribed(
     fun onTrackUnsubscribed(
         track: Track,
         track: Track,
         publication: RemoteTrackPublication,
         publication: RemoteTrackPublication,
-        participant: RemoteParticipant
+        participant: RemoteParticipant,
     ) {
     ) {
     }
     }
 
 
@@ -453,7 +452,8 @@ enum class ConnectionQuality {
     EXCELLENT,
     EXCELLENT,
     GOOD,
     GOOD,
     POOR,
     POOR,
-    UNKNOWN;
+    UNKNOWN,
+    ;
 
 
     companion object {
     companion object {
         fun fromProto(proto: LivekitModels.ConnectionQuality): ConnectionQuality {
         fun fromProto(proto: LivekitModels.ConnectionQuality): ConnectionQuality {
@@ -485,4 +485,4 @@ data class ParticipantPermission(
             )
             )
         }
         }
     }
     }
-}
+}

@@ -31,7 +31,6 @@ import livekit.LivekitRtc
 import org.webrtc.AudioTrack
 import org.webrtc.AudioTrack
 import org.webrtc.MediaStreamTrack
 import org.webrtc.MediaStreamTrack
 import org.webrtc.RtpReceiver
 import org.webrtc.RtpReceiver
-import org.webrtc.RtpTransceiver
 import org.webrtc.VideoTrack
 import org.webrtc.VideoTrack
 
 
 class RemoteParticipant(
 class RemoteParticipant(
@@ -135,7 +134,7 @@ class RemoteParticipant(
             } else {
             } else {
                 coroutineScope.launch {
                 coroutineScope.launch {
                     delay(150)
                     delay(150)
-                    addSubscribedMediaTrack(mediaTrack, sid, statsGetter,receiver = receiver, autoManageVideo, triesLeft - 1)
+                    addSubscribedMediaTrack(mediaTrack, sid, statsGetter, receiver = receiver, autoManageVideo, triesLeft - 1)
                 }
                 }
             }
             }
             return
             return

@@ -19,5 +19,4 @@ package io.livekit.android.room.track
 import org.webrtc.AudioTrack
 import org.webrtc.AudioTrack
 
 
 abstract class AudioTrack(name: String, override val rtcTrack: AudioTrack) :
 abstract class AudioTrack(name: String, override val rtcTrack: AudioTrack) :
-    Track(name, Kind.AUDIO, rtcTrack) {
-}
+    Track(name, Kind.AUDIO, rtcTrack)

@@ -19,4 +19,4 @@ package io.livekit.android.room.track
 enum class DataPublishReliability {
 enum class DataPublishReliability {
     RELIABLE,
     RELIABLE,
     LOSSY,
     LOSSY,
-}
+}

@@ -55,7 +55,7 @@ constructor(
     context,
     context,
     eglBase,
     eglBase,
     defaultsManager,
     defaultsManager,
-    videoTrackFactory
+    videoTrackFactory,
 ) {
 ) {
 
 
     private val serviceConnection = ScreenCaptureConnection(context)
     private val serviceConnection = ScreenCaptureConnection(context)
@@ -128,7 +128,7 @@ constructor(
             name: String,
             name: String,
             options: LocalVideoTrackOptions,
             options: LocalVideoTrackOptions,
             rootEglBase: EglBase,
             rootEglBase: EglBase,
-            screencastVideoTrackFactory: Factory
+            screencastVideoTrackFactory: Factory,
         ): LocalScreencastVideoTrack {
         ): LocalScreencastVideoTrack {
             val source = peerConnectionFactory.createVideoSource(options.isScreencast)
             val source = peerConnectionFactory.createVideoSource(options.isScreencast)
             val callback = MediaProjectionCallback()
             val callback = MediaProjectionCallback()
@@ -136,7 +136,7 @@ constructor(
             capturer.initialize(
             capturer.initialize(
                 SurfaceTextureHelper.create("ScreenVideoCaptureThread", rootEglBase.eglBaseContext),
                 SurfaceTextureHelper.create("ScreenVideoCaptureThread", rootEglBase.eglBaseContext),
                 context,
                 context,
-                source.capturerObserver
+                source.capturerObserver,
             )
             )
             val track = peerConnectionFactory.createVideoTrack(UUID.randomUUID().toString(), source)
             val track = peerConnectionFactory.createVideoTrack(UUID.randomUUID().toString(), source)
 
 
@@ -146,16 +146,15 @@ constructor(
                 options = options,
                 options = options,
                 name = name,
                 name = name,
                 rtcTrack = track,
                 rtcTrack = track,
-                mediaProjectionCallback = callback
+                mediaProjectionCallback = callback,
             )
             )
         }
         }
 
 
-
         private fun createScreenCapturer(
         private fun createScreenCapturer(
             resultData: Intent,
             resultData: Intent,
-            callback: MediaProjectionCallback
+            callback: MediaProjectionCallback,
         ): ScreenCapturerAndroid {
         ): ScreenCapturerAndroid {
             return ScreenCapturerAndroid(resultData, callback)
             return ScreenCapturerAndroid(resultData, callback)
         }
         }
     }
     }
-}
+}

@@ -21,7 +21,6 @@ import android.content.Context
 import android.content.pm.PackageManager
 import android.content.pm.PackageManager
 import android.hardware.camera2.CameraManager
 import android.hardware.camera2.CameraManager
 import androidx.core.content.ContextCompat
 import androidx.core.content.ContextCompat
-import com.github.ajalt.timberkt.Timber
 import dagger.assisted.Assisted
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import dagger.assisted.AssistedInject
@@ -36,7 +35,6 @@ import org.webrtc.*
 import org.webrtc.CameraVideoCapturer.CameraEventsHandler
 import org.webrtc.CameraVideoCapturer.CameraEventsHandler
 import java.util.*
 import java.util.*
 
 
-
 /**
 /**
  * A representation of a local video track (generally input coming from camera or screen).
  * A representation of a local video track (generally input coming from camera or screen).
  *
  *
@@ -116,7 +114,6 @@ constructor(
      * this will switch to the next camera, if one is available.
      * this will switch to the next camera, if one is available.
      */
      */
     fun switchCamera(deviceId: String? = null, position: CameraPosition? = null) {
     fun switchCamera(deviceId: String? = null, position: CameraPosition? = null) {
-
         val cameraCapturer = capturer as? CameraVideoCapturer ?: run {
         val cameraCapturer = capturer as? CameraVideoCapturer ?: run {
             LKLog.w { "Attempting to switch camera on a non-camera video track!" }
             LKLog.w { "Attempting to switch camera on a non-camera video track!" }
             return
             return
@@ -183,7 +180,6 @@ constructor(
             override fun onCameraSwitchError(errorDescription: String?) {
             override fun onCameraSwitchError(errorDescription: String?) {
                 LKLog.w { "switching camera failed: $errorDescription" }
                 LKLog.w { "switching camera failed: $errorDescription" }
             }
             }
-
         }
         }
         if (targetDeviceId == null) {
         if (targetDeviceId == null) {
             LKLog.w { "No target camera found!" }
             LKLog.w { "No target camera found!" }
@@ -197,7 +193,6 @@ constructor(
      * Restart a track with new options.
      * Restart a track with new options.
      */
      */
     fun restartTrack(options: LocalVideoTrackOptions = defaultsManager.videoTrackCaptureDefaults.copy()) {
     fun restartTrack(options: LocalVideoTrackOptions = defaultsManager.videoTrackCaptureDefaults.copy()) {
-
         val oldCapturer = capturer
         val oldCapturer = capturer
         val oldSource = source
         val oldSource = source
         val oldRtcTrack = rtcTrack
         val oldRtcTrack = rtcTrack
@@ -293,7 +288,6 @@ constructor(
             trackFactory: Factory,
             trackFactory: Factory,
             videoProcessor: VideoProcessor? = null,
             videoProcessor: VideoProcessor? = null,
         ): LocalVideoTrack {
         ): LocalVideoTrack {
-
             if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) !=
             if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) !=
                 PackageManager.PERMISSION_GRANTED
                 PackageManager.PERMISSION_GRANTED
             ) {
             ) {
@@ -450,5 +444,4 @@ constructor(
             return null
             return null
         }
         }
     }
     }
-
 }
 }

@@ -26,7 +26,7 @@ data class LocalVideoTrackOptions(
      */
      */
     val deviceId: String? = null,
     val deviceId: String? = null,
     val position: CameraPosition? = CameraPosition.FRONT,
     val position: CameraPosition? = CameraPosition.FRONT,
-    val captureParams: VideoCaptureParameter = VideoPreset169.QHD.capture
+    val captureParams: VideoCaptureParameter = VideoPreset169.QHD.capture,
 )
 )
 
 
 data class VideoCaptureParameter(
 data class VideoCaptureParameter(
@@ -56,7 +56,6 @@ data class VideoEncoding(
                 networkPriority = 1 // low, from priority.h in webrtc
                 networkPriority = 1 // low, from priority.h in webrtc
                 bitratePriority = 1.0
                 bitratePriority = 1.0
             }
             }
-
         }
         }
     }
     }
 }
 }
@@ -68,7 +67,7 @@ enum class VideoCodec(val codecName: String) {
 
 
 enum class CameraPosition {
 enum class CameraPosition {
     FRONT,
     FRONT,
-    BACK
+    BACK,
 }
 }
 
 
 interface VideoPreset {
 interface VideoPreset {
@@ -125,26 +124,30 @@ enum class VideoPreset169(
         VideoCaptureParameter(320, 180, 15),
         VideoCaptureParameter(320, 180, 15),
         VideoEncoding(125_000, 15),
         VideoEncoding(125_000, 15),
     ),
     ),
+
     @Deprecated("VGA is deprecated, use H360 instead")
     @Deprecated("VGA is deprecated, use H360 instead")
     VGA(
     VGA(
         VideoCaptureParameter(640, 360, 30),
         VideoCaptureParameter(640, 360, 30),
         VideoEncoding(400_000, 30),
         VideoEncoding(400_000, 30),
     ),
     ),
+
     @Deprecated("QHD is deprecated, use H540 instead")
     @Deprecated("QHD is deprecated, use H540 instead")
     QHD(
     QHD(
         VideoCaptureParameter(960, 540, 30),
         VideoCaptureParameter(960, 540, 30),
         VideoEncoding(800_000, 30),
         VideoEncoding(800_000, 30),
     ),
     ),
+
     @Deprecated("HD is deprecated, use H720 instead")
     @Deprecated("HD is deprecated, use H720 instead")
     HD(
     HD(
         VideoCaptureParameter(1280, 720, 30),
         VideoCaptureParameter(1280, 720, 30),
         VideoEncoding(2_500_000, 30),
         VideoEncoding(2_500_000, 30),
     ),
     ),
+
     @Deprecated("FHD is deprecated, use H1080 instead")
     @Deprecated("FHD is deprecated, use H1080 instead")
     FHD(
     FHD(
         VideoCaptureParameter(1920, 1080, 30),
         VideoCaptureParameter(1920, 1080, 30),
         VideoEncoding(4_000_000, 30),
         VideoEncoding(4_000_000, 30),
-    )
+    ),
 }
 }
 
 
 /**
 /**
@@ -196,24 +199,28 @@ enum class VideoPreset43(
         VideoCaptureParameter(240, 180, 15),
         VideoCaptureParameter(240, 180, 15),
         VideoEncoding(100_000, 15),
         VideoEncoding(100_000, 15),
     ),
     ),
+
     @Deprecated("VGA is deprecated, use H360 instead")
     @Deprecated("VGA is deprecated, use H360 instead")
     VGA(
     VGA(
         VideoCaptureParameter(480, 360, 30),
         VideoCaptureParameter(480, 360, 30),
         VideoEncoding(320_000, 30),
         VideoEncoding(320_000, 30),
     ),
     ),
+
     @Deprecated("QHD is deprecated, use H540 instead")
     @Deprecated("QHD is deprecated, use H540 instead")
     QHD(
     QHD(
         VideoCaptureParameter(720, 540, 30),
         VideoCaptureParameter(720, 540, 30),
         VideoEncoding(640_000, 30),
         VideoEncoding(640_000, 30),
     ),
     ),
+
     @Deprecated("HD is deprecated, use H720 instead")
     @Deprecated("HD is deprecated, use H720 instead")
     HD(
     HD(
         VideoCaptureParameter(960, 720, 30),
         VideoCaptureParameter(960, 720, 30),
         VideoEncoding(2_000_000, 30),
         VideoEncoding(2_000_000, 30),
     ),
     ),
+
     @Deprecated("FHD is deprecated, use H1080 instead")
     @Deprecated("FHD is deprecated, use H1080 instead")
     FHD(
     FHD(
         VideoCaptureParameter(1440, 1080, 30),
         VideoCaptureParameter(1440, 1080, 30),
         VideoEncoding(3_200_000, 30),
         VideoEncoding(3_200_000, 30),
-    )
-}
+    ),
+}

@@ -153,10 +153,10 @@ class RemoteTrackPublication(
      * Will override previous calls to [setVideoDimensions].
      * Will override previous calls to [setVideoDimensions].
      */
      */
     fun setVideoQuality(quality: LivekitModels.VideoQuality) {
     fun setVideoQuality(quality: LivekitModels.VideoQuality) {
-        if (isAutoManaged
-            || !subscribed
-            || quality == videoQuality
-            || track !is VideoTrack
+        if (isAutoManaged ||
+            !subscribed ||
+            quality == videoQuality ||
+            track !is VideoTrack
         ) {
         ) {
             return
             return
         }
         }
@@ -171,10 +171,10 @@ class RemoteTrackPublication(
      * Will override previous calls to [setVideoQuality].
      * Will override previous calls to [setVideoQuality].
      */
      */
     fun setVideoDimensions(dimensions: Track.Dimensions) {
     fun setVideoDimensions(dimensions: Track.Dimensions) {
-        if (isAutoManaged
-            || !subscribed
-            || videoDimensions == dimensions
-            || track !is VideoTrack
+        if (isAutoManaged ||
+            !subscribed ||
+            videoDimensions == dimensions ||
+            track !is VideoTrack
         ) {
         ) {
             return
             return
         }
         }
@@ -188,10 +188,10 @@ class RemoteTrackPublication(
      * Update the fps that the server will use for determining the video quality to send down.
      * Update the fps that the server will use for determining the video quality to send down.
      */
      */
     fun setVideoFps(fps: Int?) {
     fun setVideoFps(fps: Int?) {
-        if (isAutoManaged
-            || !subscribed
-            || this.fps == fps
-            || track !is VideoTrack
+        if (isAutoManaged ||
+            !subscribed ||
+            this.fps == fps ||
+            track !is VideoTrack
         ) {
         ) {
             return
             return
         }
         }
@@ -232,7 +232,7 @@ class RemoteTrackPublication(
             disabled,
             disabled,
             videoDimensions,
             videoDimensions,
             videoQuality,
             videoQuality,
-            fps
+            fps,
         )
         )
     }
     }
 
 
@@ -250,6 +250,6 @@ class RemoteTrackPublication(
         /**
         /**
          * Not subscribed.
          * Not subscribed.
          */
          */
-        UNSUBSCRIBED
+        UNSUBSCRIBED,
     }
     }
-}
+}

@@ -25,7 +25,6 @@ import io.livekit.android.room.track.video.ViewVisibility
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.LKLog
 import kotlinx.coroutines.*
 import kotlinx.coroutines.*
 import org.webrtc.RtpReceiver
 import org.webrtc.RtpReceiver
-import org.webrtc.RtpTransceiver
 import org.webrtc.VideoSink
 import org.webrtc.VideoSink
 import javax.inject.Named
 import javax.inject.Named
 import kotlin.math.max
 import kotlin.math.max
@@ -136,4 +135,4 @@ class RemoteVideoTrack(
         super.dispose()
         super.dispose()
         coroutineScope.cancel()
         coroutineScope.cancel()
     }
     }
-}
+}

@@ -30,7 +30,7 @@ import org.webrtc.RTCStatsReport
 abstract class Track(
 abstract class Track(
     name: String,
     name: String,
     kind: Kind,
     kind: Kind,
-    open val rtcTrack: MediaStreamTrack
+    open val rtcTrack: MediaStreamTrack,
 ) {
 ) {
     protected val eventBus = BroadcastEventBus<TrackEvent>()
     protected val eventBus = BroadcastEventBus<TrackEvent>()
     val events = eventBus.readOnly()
     val events = eventBus.readOnly()
@@ -67,7 +67,8 @@ abstract class Track(
         VIDEO("video"),
         VIDEO("video"),
 
 
         // unknown
         // unknown
-        UNRECOGNIZED("unrecognized");
+        UNRECOGNIZED("unrecognized"),
+        ;
 
 
         fun toProto(): LivekitModels.TrackType {
         fun toProto(): LivekitModels.TrackType {
             return when (this) {
             return when (this) {
@@ -78,7 +79,7 @@ abstract class Track(
         }
         }
 
 
         override fun toString(): String {
         override fun toString(): String {
-            return value;
+            return value
         }
         }
 
 
         companion object {
         companion object {
@@ -96,8 +97,8 @@ abstract class Track(
         CAMERA,
         CAMERA,
         MICROPHONE,
         MICROPHONE,
         SCREEN_SHARE,
         SCREEN_SHARE,
-        UNKNOWN;
-
+        UNKNOWN,
+        ;
 
 
         fun toProto(): LivekitModels.TrackSource {
         fun toProto(): LivekitModels.TrackSource {
             return when (this) {
             return when (this) {
@@ -123,7 +124,8 @@ abstract class Track(
     enum class StreamState {
     enum class StreamState {
         ACTIVE,
         ACTIVE,
         PAUSED,
         PAUSED,
-        UNKNOWN;
+        UNKNOWN,
+        ;
 
 
         fun toProto(): LivekitRtc.StreamState {
         fun toProto(): LivekitRtc.StreamState {
             return when (this) {
             return when (this) {
@@ -159,7 +161,6 @@ abstract class Track(
     }
     }
 }
 }
 
 
-
 sealed class TrackException(message: String? = null, cause: Throwable? = null) :
 sealed class TrackException(message: String? = null, cause: Throwable? = null) :
     Exception(message, cause) {
     Exception(message, cause) {
     class InvalidTrackTypeException(message: String? = null, cause: Throwable? = null) :
     class InvalidTrackTypeException(message: String? = null, cause: Throwable? = null) :
@@ -176,4 +177,4 @@ sealed class TrackException(message: String? = null, cause: Throwable? = null) :
 
 
     class PublishException(message: String? = null, cause: Throwable? = null) :
     class PublishException(message: String? = null, cause: Throwable? = null) :
         TrackException(message, cause)
         TrackException(message, cause)
-}
+}

@@ -21,7 +21,7 @@ import org.webrtc.VideoTrack
 
 
 abstract class VideoTrack(name: String, override val rtcTrack: VideoTrack) :
 abstract class VideoTrack(name: String, override val rtcTrack: VideoTrack) :
     Track(name, Kind.VIDEO, rtcTrack) {
     Track(name, Kind.VIDEO, rtcTrack) {
-    protected val sinks: MutableList<VideoSink> = ArrayList();
+    protected val sinks: MutableList<VideoSink> = ArrayList()
 
 
     var enabled: Boolean
     var enabled: Boolean
         get() = rtcTrack.enabled()
         get() = rtcTrack.enabled()

@@ -88,4 +88,4 @@ internal class ScreenCaptureConnection(private val context: Context) {
         service = null
         service = null
         isBound = false
         isBound = false
     }
     }
-}
+}

@@ -67,7 +67,7 @@ open class ScreenCaptureService : Service() {
         val channel = NotificationChannel(
         val channel = NotificationChannel(
             DEFAULT_CHANNEL_ID,
             DEFAULT_CHANNEL_ID,
             "Screen Capture",
             "Screen Capture",
-            NotificationManager.IMPORTANCE_LOW
+            NotificationManager.IMPORTANCE_LOW,
         )
         )
         val service = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         val service = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         service.createNotificationChannel(channel)
         service.createNotificationChannel(channel)
@@ -82,7 +82,6 @@ open class ScreenCaptureService : Service() {
         return false
         return false
     }
     }
 
 
-
     inner class ScreenCaptureBinder : Binder() {
     inner class ScreenCaptureBinder : Binder() {
         val service: ScreenCaptureService
         val service: ScreenCaptureService
             get() = this@ScreenCaptureService
             get() = this@ScreenCaptureService
@@ -92,4 +91,4 @@ open class ScreenCaptureService : Service() {
         const val DEFAULT_NOTIFICATION_ID = 2345
         const val DEFAULT_NOTIFICATION_ID = 2345
         const val DEFAULT_CHANNEL_ID = "livekit_screen_capture"
         const val DEFAULT_CHANNEL_ID = "livekit_screen_capture"
     }
     }
-}
+}

@@ -128,4 +128,4 @@ open class BitmapFrameCapturer : VideoCapturer {
             }
             }
         }
         }
     }
     }
-}
+}

@@ -77,5 +77,4 @@ internal class CameraEventsDispatchHandler : CameraEventsHandler {
             handler.onCameraClosed()
             handler.onCameraClosed()
         }
         }
     }
     }
-
-}
+}

@@ -31,7 +31,7 @@ internal interface VideoCapturerWithSize : VideoCapturer {
  */
  */
 
 
 internal abstract class CameraCapturerWithSize(
 internal abstract class CameraCapturerWithSize(
-    val cameraEventsDispatchHandler: CameraEventsDispatchHandler
+    val cameraEventsDispatchHandler: CameraEventsDispatchHandler,
 ) : VideoCapturerWithSize
 ) : VideoCapturerWithSize
 
 
 /**
 /**
@@ -60,4 +60,4 @@ internal class Camera2CapturerWithSize(
     override fun findCaptureFormat(width: Int, height: Int): Size {
     override fun findCaptureFormat(width: Int, height: Int): Size {
         return Camera2Helper.findClosestCaptureFormat(cameraManager, deviceName, width, height)
         return Camera2Helper.findClosestCaptureFormat(cameraManager, deviceName, width, height)
     }
     }
-}
+}

@@ -55,8 +55,8 @@ class ComposeVisibility : VideoSinkVisibility() {
     private var lastSize = size()
     private var lastSize = size()
     override fun isVisible(): Boolean {
     override fun isVisible(): Boolean {
         return (coordinates?.isAttached == true &&
         return (coordinates?.isAttached == true &&
-                coordinates?.size?.width != 0 &&
-                coordinates?.size?.height != 0)
+            coordinates?.size?.width != 0 &&
+            coordinates?.size?.height != 0)
     }
     }
 
 
     override fun size(): Track.Dimensions {
     override fun size(): Track.Dimensions {
@@ -185,4 +185,4 @@ class ViewVisibility(private val view: View) : VideoSinkVisibility() {
             view.viewVisibility = null
             view.viewVisibility = null
         }
         }
     }
     }
-}
+}

@@ -113,4 +113,4 @@ suspend fun PeerConnection.setLocalDescription(description: SessionDescription):
     val observer = CoroutineSdpObserver()
     val observer = CoroutineSdpObserver()
     this.setLocalDescription(observer, description)
     this.setLocalDescription(observer, description)
     return observer.awaitSet()
     return observer.awaitSet()
-}
+}

@@ -40,7 +40,7 @@ internal object EncodingUtils {
         VideoPreset169.H720,
         VideoPreset169.H720,
         VideoPreset169.H1080,
         VideoPreset169.H1080,
         VideoPreset169.H1440,
         VideoPreset169.H1440,
-        VideoPreset169.H2160
+        VideoPreset169.H2160,
     )
     )
 
 
     // Note: maintain order from smallest to biggest.
     // Note: maintain order from smallest to biggest.
@@ -82,7 +82,7 @@ internal object EncodingUtils {
     fun videoLayersFromEncodings(
     fun videoLayersFromEncodings(
         trackWidth: Int,
         trackWidth: Int,
         trackHeight: Int,
         trackHeight: Int,
-        encodings: List<RtpParameters.Encoding>
+        encodings: List<RtpParameters.Encoding>,
     ): List<LivekitModels.VideoLayer> {
     ): List<LivekitModels.VideoLayer> {
         return if (encodings.isEmpty()) {
         return if (encodings.isEmpty()) {
             listOf(
             listOf(
@@ -92,7 +92,7 @@ internal object EncodingUtils {
                     quality = LivekitModels.VideoQuality.HIGH
                     quality = LivekitModels.VideoQuality.HIGH
                     bitrate = 0
                     bitrate = 0
                     ssrc = 0
                     ssrc = 0
-                }.build()
+                }.build(),
             )
             )
         } else {
         } else {
             encodings.map { encoding ->
             encodings.map { encoding ->
@@ -131,4 +131,4 @@ internal object EncodingUtils {
             else -> null
             else -> null
         }
         }
     }
     }
-}
+}

@@ -30,4 +30,4 @@ object MediaConstraintKeys {
 fun MediaConstraints.findConstraint(key: String): String? {
 fun MediaConstraints.findConstraint(key: String): String? {
     return mandatory.firstOrNull { it.key == key }?.value
     return mandatory.firstOrNull { it.key == key }?.value
         ?: optional.firstOrNull { it.key == key }?.value
         ?: optional.firstOrNull { it.key == key }?.value
-}
+}

@@ -16,8 +16,6 @@
 
 
 package io.livekit.android.room.util
 package io.livekit.android.room.util
 
 
-import io.livekit.android.room.participant.Participant
-import io.livekit.android.room.track.Track
 import org.webrtc.DataChannel
 import org.webrtc.DataChannel
 
 
 fun DataChannel.unpackedTrackLabel(): Triple<String, String, String> {
 fun DataChannel.unpackedTrackLabel(): Triple<String, String, String> {
@@ -35,6 +33,6 @@ fun DataChannel.unpackedTrackLabel(): Triple<String, String, String> {
         trackSid = ""
         trackSid = ""
         name = ""
         name = ""
     }
     }
-    
+
     return Triple(participantSid, trackSid, name)
     return Triple(participantSid, trackSid, name)
-}
+}

@@ -74,4 +74,4 @@ enum class NetworkType(val protoName: String) {
     BLUETOOTH("bluetooth"),
     BLUETOOTH("bluetooth"),
     OTHER("other"),
     OTHER("other"),
     UNKNOWN(""),
     UNKNOWN(""),
-}
+}

@@ -30,7 +30,6 @@ internal class NetworkMonitor(private val context: Context) {
         coroutineContext = SupervisorJob() + Dispatchers.IO
         coroutineContext = SupervisorJob() + Dispatchers.IO
         scope = CoroutineScope(coroutineContext)
         scope = CoroutineScope(coroutineContext)
         scope.launch {
         scope.launch {
-
             val uid = context.packageManager.getApplicationInfo(context.packageName, 0).uid
             val uid = context.packageManager.getApplicationInfo(context.packageName, 0).uid
 
 
             var prevTxBytes = TrafficStats.getUidTxBytes(uid)
             var prevTxBytes = TrafficStats.getUidTxBytes(uid)
@@ -70,4 +69,4 @@ internal class NetworkMonitor(private val context: Context) {
     fun stop() {
     fun stop() {
         coroutineContext.cancel()
         coroutineContext.cancel()
     }
     }
-}
+}

@@ -27,4 +27,4 @@ internal class CloseableCoroutineScope(context: CoroutineContext) : Closeable, C
     override fun close() {
     override fun close() {
         coroutineContext.cancel()
         coroutineContext.cancel()
     }
     }
-}
+}

@@ -21,7 +21,7 @@ import kotlinx.coroutines.*
 fun <T, R> debounce(
 fun <T, R> debounce(
     waitMs: Long = 300L,
     waitMs: Long = 300L,
     coroutineScope: CoroutineScope,
     coroutineScope: CoroutineScope,
-    destinationFunction: suspend (T) -> R
+    destinationFunction: suspend (T) -> R,
 ): (T) -> Unit {
 ): (T) -> Unit {
     var debounceJob: Deferred<R>? = null
     var debounceJob: Deferred<R>? = null
     return { param: T ->
     return { param: T ->
@@ -35,4 +35,4 @@ fun <T, R> debounce(
 
 
 fun <R> ((Unit) -> R).invoke() {
 fun <R> ((Unit) -> R).invoke() {
     this.invoke(Unit)
     this.invoke(Unit)
-}
+}

@@ -19,4 +19,4 @@ package io.livekit.android.util
 sealed class Either<out A, out B> {
 sealed class Either<out A, out B> {
     class Left<A>(val value: A) : Either<A, Nothing>()
     class Left<A>(val value: A) : Either<A, Nothing>()
     class Right<B>(val value: B) : Either<Nothing, B>()
     class Right<B>(val value: B) : Either<Nothing, B>()
-}
+}

@@ -34,7 +34,6 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty0
 import kotlin.reflect.KProperty0
 
 
-
 /**
 /**
  * A little circuitous but the way this works is:
  * A little circuitous but the way this works is:
  * 1. [delegateRequested] set to true indicates that [delegate] should be filled.
  * 1. [delegateRequested] set to true indicates that [delegate] should be filled.
@@ -74,7 +73,7 @@ annotation class FlowObservable
 internal class MutableStateFlowDelegate<T>
 internal class MutableStateFlowDelegate<T>
 internal constructor(
 internal constructor(
     private val flow: MutableStateFlow<T>,
     private val flow: MutableStateFlow<T>,
-    private val onSetValue: ((newValue: T, oldValue: T) -> Unit)? = null
+    private val onSetValue: ((newValue: T, oldValue: T) -> Unit)? = null,
 ) : MutableStateFlow<T> by flow {
 ) : MutableStateFlow<T> by flow {
 
 
     operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
     operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
@@ -94,7 +93,7 @@ internal constructor(
 @FlowObservable
 @FlowObservable
 internal class StateFlowDelegate<T>
 internal class StateFlowDelegate<T>
 internal constructor(
 internal constructor(
-    private val flow: StateFlow<T>
+    private val flow: StateFlow<T>,
 ) : StateFlow<T> by flow {
 ) : StateFlow<T> by flow {
 
 
     operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
     operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
@@ -107,13 +106,13 @@ internal constructor(
 
 
 internal fun <T> flowDelegate(
 internal fun <T> flowDelegate(
     initialValue: T,
     initialValue: T,
-    onSetValue: ((newValue: T, oldValue: T) -> Unit)? = null
+    onSetValue: ((newValue: T, oldValue: T) -> Unit)? = null,
 ): MutableStateFlowDelegate<T> {
 ): MutableStateFlowDelegate<T> {
     return MutableStateFlowDelegate(MutableStateFlow(initialValue), onSetValue)
     return MutableStateFlowDelegate(MutableStateFlow(initialValue), onSetValue)
 }
 }
 
 
 internal fun <T> flowDelegate(
 internal fun <T> flowDelegate(
-    stateFlow: StateFlow<T>
+    stateFlow: StateFlow<T>,
 ): StateFlowDelegate<T> {
 ): StateFlowDelegate<T> {
     return StateFlowDelegate(stateFlow)
     return StateFlowDelegate(stateFlow)
-}
+}

+/*
+ * Copyright 2023 LiveKit, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.livekit.android.util
 package io.livekit.android.util
 
 
 import io.livekit.android.util.LoggingLevel.*
 import io.livekit.android.util.LoggingLevel.*
@@ -25,7 +41,6 @@ internal class LKLog {
     companion object {
     companion object {
         var loggingLevel = OFF
         var loggingLevel = OFF
 
 
-
         /** Log a verbose exception and a message that will be evaluated lazily when the message is printed */
         /** Log a verbose exception and a message that will be evaluated lazily when the message is printed */
         @JvmStatic
         @JvmStatic
         inline fun v(t: Throwable? = null, message: () -> String) =
         inline fun v(t: Throwable? = null, message: () -> String) =

@@ -25,7 +25,8 @@ enum class LoggingLevel {
     WARN,
     WARN,
     ERROR,
     ERROR,
     WTF,
     WTF,
-    OFF;
+    OFF,
+    ;
 
 
     fun toAndroidLogPriority(): Int {
     fun toAndroidLogPriority(): Int {
         return when (this) {
         return when (this) {
@@ -39,4 +40,3 @@ enum class LoggingLevel {
         }
         }
     }
     }
 }
 }
-

@@ -23,4 +23,4 @@ import okio.ByteString.Companion.toByteString
 fun MessageLite.toOkioByteString(): ByteString {
 fun MessageLite.toOkioByteString(): ByteString {
     val byteArray = toByteArray()
     val byteArray = toByteArray()
     return byteArray.toByteString(0, byteArray.size)
     return byteArray.toByteString(0, byteArray.size)
-}
+}

@@ -92,4 +92,4 @@ internal fun RTCConfiguration.copyFrom(config: RTCConfiguration) {
     turnLoggingId = config.turnLoggingId
     turnLoggingId = config.turnLoggingId
     enableImplicitRollback = config.enableImplicitRollback
     enableImplicitRollback = config.enableImplicitRollback
     offerExtmapAllowMixed = config.offerExtmapAllowMixed
     offerExtmapAllowMixed = config.offerExtmapAllowMixed
-}
+}

@@ -98,8 +98,8 @@ fun RTCStatsReport.getFilteredStats(trackIdentifier: String): RTCStatsReport {
             codecIds,
             codecIds,
             localCandidateId,
             localCandidateId,
             remoteCandidateId,
             remoteCandidateId,
-            statsMap
-        )
+            statsMap,
+        ),
     )
     )
     val filteredStatsMap: MutableMap<String, RTCStats> = HashMap()
     val filteredStatsMap: MutableMap<String, RTCStats> = HashMap()
     for (stats in filteredStats) {
     for (stats in filteredStats) {
@@ -120,7 +120,6 @@ private fun getTrackStats(trackIdentifier: String, statsMap: Map<String, RTCStat
     return null
     return null
 }
 }
 
 
-
 private fun getStreamStats(trackId: String, statsMap: Map<String, RTCStats>): RTCStats? {
 private fun getStreamStats(trackId: String, statsMap: Map<String, RTCStats>): RTCStats? {
     for (stats in statsMap.values) {
     for (stats in statsMap.values) {
         if (stats.type == "stream") {
         if (stats.type == "stream") {
@@ -141,7 +140,7 @@ private fun getExtraStats(
     codecIds: Set<String?>,
     codecIds: Set<String?>,
     localCandidateId: String?,
     localCandidateId: String?,
     remoteCandidateId: String?,
     remoteCandidateId: String?,
-    statsMap: Map<String, RTCStats>
+    statsMap: Map<String, RTCStats>,
 ): Set<RTCStats> {
 ): Set<RTCStats> {
     val extraStats: MutableSet<RTCStats> = HashSet()
     val extraStats: MutableSet<RTCStats> = HashSet()
     for (stats in statsMap.values) {
     for (stats in statsMap.values) {
@@ -185,4 +184,3 @@ fun createStatsGetter(peerConnection: PeerConnection, receiver: RtpReceiver): RT
     { statsCallback: RTCStatsCollectorCallback ->
     { statsCallback: RTCStatsCollectorCallback ->
         peerConnection.getStats(receiver, statsCallback)
         peerConnection.getStats(receiver, statsCallback)
     }
     }
-

@@ -25,4 +25,4 @@ fun SessionDescription.toProtoSessionDescription(): LivekitRtc.SessionDescriptio
     sdBuilder.type = type.canonicalForm()
     sdBuilder.type = type.canonicalForm()
 
 
     return sdBuilder.build()
     return sdBuilder.build()
-}
+}

+/*
+ * Copyright 2023 LiveKit, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.livekit.android.webrtc
 package io.livekit.android.webrtc
 
 
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.LKLog
@@ -25,7 +41,7 @@ limitations under the License.
 open class SimulcastVideoEncoderFactoryWrapper(
 open class SimulcastVideoEncoderFactoryWrapper(
     sharedContext: EglBase.Context?,
     sharedContext: EglBase.Context?,
     enableIntelVp8Encoder: Boolean,
     enableIntelVp8Encoder: Boolean,
-    enableH264HighProfile: Boolean
+    enableH264HighProfile: Boolean,
 ) : VideoEncoderFactory {
 ) : VideoEncoderFactory {
 
 
     /**
     /**
@@ -72,7 +88,6 @@ open class SimulcastVideoEncoderFactoryWrapper(
             supportedCodecInfos.addAll(hardwareVideoEncoderFactory.supportedCodecs)
             supportedCodecInfos.addAll(hardwareVideoEncoderFactory.supportedCodecs)
             return supportedCodecInfos.toTypedArray()
             return supportedCodecInfos.toTypedArray()
         }
         }
-
     }
     }
 
 
     /**
     /**
@@ -89,12 +104,13 @@ open class SimulcastVideoEncoderFactoryWrapper(
 
 
         override fun initEncode(
         override fun initEncode(
             settings: VideoEncoder.Settings,
             settings: VideoEncoder.Settings,
-            callback: VideoEncoder.Callback?
+            callback: VideoEncoder.Callback?,
         ): VideoCodecStatus {
         ): VideoCodecStatus {
             streamSettings = settings
             streamSettings = settings
-            val future = executor.submit(Callable {
-                LKLog.i {
-                    """initEncode() thread=${Thread.currentThread().name} [${Thread.currentThread().id}]
+            val future = executor.submit(
+                Callable {
+                    LKLog.i {
+                        """initEncode() thread=${Thread.currentThread().name} [${Thread.currentThread().id}]
                 |  encoder=${encoder.implementationName}
                 |  encoder=${encoder.implementationName}
                 |  streamSettings:
                 |  streamSettings:
                 |    numberOfCores=${settings.numberOfCores}
                 |    numberOfCores=${settings.numberOfCores}
@@ -105,10 +121,11 @@ open class SimulcastVideoEncoderFactoryWrapper(
                 |    automaticResizeOn=${settings.automaticResizeOn}
                 |    automaticResizeOn=${settings.automaticResizeOn}
                 |    numberOfSimulcastStreams=${settings.numberOfSimulcastStreams}
                 |    numberOfSimulcastStreams=${settings.numberOfSimulcastStreams}
                 |    lossNotification=${settings.capabilities.lossNotification}
                 |    lossNotification=${settings.capabilities.lossNotification}
-            """.trimMargin()
-                }
-                return@Callable encoder.initEncode(settings, callback)
-            })
+                        """.trimMargin()
+                    }
+                    return@Callable encoder.initEncode(settings, callback)
+                },
+            )
             return future.get()
             return future.get()
         }
         }
 
 
@@ -119,43 +136,51 @@ open class SimulcastVideoEncoderFactoryWrapper(
 
 
         override fun encode(
         override fun encode(
             frame: VideoFrame,
             frame: VideoFrame,
-            encodeInfo: VideoEncoder.EncodeInfo?
+            encodeInfo: VideoEncoder.EncodeInfo?,
         ): VideoCodecStatus {
         ): VideoCodecStatus {
-            val future = executor.submit(Callable {
-                //LKLog.d { "encode() buffer=${frame.buffer}, thread=${Thread.currentThread().name} " +
-                //        "[${Thread.currentThread().id}]" }
-                if (streamSettings == null) {
-                    return@Callable encoder.encode(frame, encodeInfo)
-                } else if (frame.buffer.width == streamSettings!!.width) {
-                    return@Callable encoder.encode(frame, encodeInfo)
-                } else {
-                    // The incoming buffer is different than the streamSettings received in initEncode()
-                    // Need to scale.
-                    val originalBuffer = frame.buffer
-                    // TODO: Do we need to handle when the scale factor is weird?
-                    val adaptedBuffer = originalBuffer.cropAndScale(
-                        0, 0, originalBuffer.width, originalBuffer.height,
-                        streamSettings!!.width, streamSettings!!.height
-                    )
-                    val adaptedFrame = VideoFrame(adaptedBuffer, frame.rotation, frame.timestampNs)
-                    val result = encoder.encode(adaptedFrame, encodeInfo)
-                    adaptedBuffer.release()
-                    return@Callable result
-                }
-            })
+            val future = executor.submit(
+                Callable {
+                    // LKLog.d { "encode() buffer=${frame.buffer}, thread=${Thread.currentThread().name} " +
+                    //        "[${Thread.currentThread().id}]" }
+                    if (streamSettings == null) {
+                        return@Callable encoder.encode(frame, encodeInfo)
+                    } else if (frame.buffer.width == streamSettings!!.width) {
+                        return@Callable encoder.encode(frame, encodeInfo)
+                    } else {
+                        // The incoming buffer is different than the streamSettings received in initEncode()
+                        // Need to scale.
+                        val originalBuffer = frame.buffer
+                        // TODO: Do we need to handle when the scale factor is weird?
+                        val adaptedBuffer = originalBuffer.cropAndScale(
+                            0,
+                            0,
+                            originalBuffer.width,
+                            originalBuffer.height,
+                            streamSettings!!.width,
+                            streamSettings!!.height,
+                        )
+                        val adaptedFrame = VideoFrame(adaptedBuffer, frame.rotation, frame.timestampNs)
+                        val result = encoder.encode(adaptedFrame, encodeInfo)
+                        adaptedBuffer.release()
+                        return@Callable result
+                    }
+                },
+            )
             return future.get()
             return future.get()
         }
         }
 
 
         override fun setRateAllocation(
         override fun setRateAllocation(
             allocation: VideoEncoder.BitrateAllocation?,
             allocation: VideoEncoder.BitrateAllocation?,
-            frameRate: Int
+            frameRate: Int,
         ): VideoCodecStatus {
         ): VideoCodecStatus {
-            val future = executor.submit(Callable {
-                return@Callable encoder.setRateAllocation(
-                    allocation,
-                    frameRate
-                )
-            })
+            val future = executor.submit(
+                Callable {
+                    return@Callable encoder.setRateAllocation(
+                        allocation,
+                        frameRate,
+                    )
+                },
+            )
             return future.get()
             return future.get()
         }
         }
 
 
@@ -202,7 +227,7 @@ open class SimulcastVideoEncoderFactoryWrapper(
             if (encoder == null) {
             if (encoder == null) {
                 return null
                 return null
             }
             }
-            if(encoder is WrappedNativeVideoEncoder){
+            if (encoder is WrappedNativeVideoEncoder) {
                 return encoder
                 return encoder
             }
             }
             return StreamEncoderWrapper(encoder)
             return StreamEncoderWrapper(encoder)
@@ -213,14 +238,15 @@ open class SimulcastVideoEncoderFactoryWrapper(
         }
         }
     }
     }
 
 
-
     private val primary: VideoEncoderFactory
     private val primary: VideoEncoderFactory
     private val fallback: VideoEncoderFactory
     private val fallback: VideoEncoderFactory
     private val native: SimulcastVideoEncoderFactory
     private val native: SimulcastVideoEncoderFactory
 
 
     init {
     init {
         val hardwareVideoEncoderFactory = HardwareVideoEncoderFactory(
         val hardwareVideoEncoderFactory = HardwareVideoEncoderFactory(
-            sharedContext, enableIntelVp8Encoder, enableH264HighProfile
+            sharedContext,
+            enableIntelVp8Encoder,
+            enableH264HighProfile,
         )
         )
         primary = StreamEncoderWrapperFactory(hardwareVideoEncoderFactory)
         primary = StreamEncoderWrapperFactory(hardwareVideoEncoderFactory)
         fallback = StreamEncoderWrapperFactory(FallbackFactory(primary))
         fallback = StreamEncoderWrapperFactory(FallbackFactory(primary))
@@ -234,5 +260,4 @@ open class SimulcastVideoEncoderFactoryWrapper(
     override fun getSupportedCodecs(): Array<VideoCodecInfo> {
     override fun getSupportedCodecs(): Array<VideoCodecInfo> {
         return native.supportedCodecs
         return native.supportedCodecs
     }
     }
-
-}
+}

@@ -32,14 +32,14 @@ internal class Camera1Helper {
         fun findClosestCaptureFormat(
         fun findClosestCaptureFormat(
             cameraId: Int,
             cameraId: Int,
             width: Int,
             width: Int,
-            height: Int
+            height: Int,
         ): Size {
         ): Size {
             return CameraEnumerationAndroid.getClosestSupportedSize(
             return CameraEnumerationAndroid.getClosestSupportedSize(
                 getSupportedFormats(cameraId)
                 getSupportedFormats(cameraId)
                     .map { Size(it.width, it.height) },
                     .map { Size(it.width, it.height) },
                 width,
                 width,
-                height
+                height,
             )
             )
         }
         }
     }
     }
-}
+}

@@ -38,7 +38,7 @@ internal class Camera2Helper {
             cameraManager: CameraManager,
             cameraManager: CameraManager,
             cameraId: String?,
             cameraId: String?,
             width: Int,
             width: Int,
-            height: Int
+            height: Int,
         ): Size {
         ): Size {
             val sizes = getSupportedFormats(cameraManager, cameraId)
             val sizes = getSupportedFormats(cameraManager, cameraId)
                 ?.map { Size(it.width, it.height) }
                 ?.map { Size(it.width, it.height) }
@@ -46,4 +46,4 @@ internal class Camera2Helper {
             return CameraEnumerationAndroid.getClosestSupportedSize(sizes, width, height)
             return CameraEnumerationAndroid.getClosestSupportedSize(sizes, width, height)
         }
         }
     }
     }
-}
+}

@@ -112,4 +112,4 @@ abstract class MockE2ETest : BaseTest() {
     fun simulateMessageFromServer(message: ByteString) {
     fun simulateMessageFromServer(message: ByteString) {
         wsFactory.listener.onMessage(wsFactory.ws, message)
         wsFactory.listener.onMessage(wsFactory.ws, message)
     }
     }
-}
+}

@@ -34,4 +34,4 @@ fun assertIsClassList(expectedClasses: List<Class<*>>, actual: List<*>) {
     }
     }
 
 
     Assert.assertEquals(expectedClasses, klazzes)
     Assert.assertEquals(expectedClasses, klazzes)
-}
+}

@@ -45,8 +45,7 @@ fun <T> Flow<T>.takeUntilSignal(signal: Flow<Unit?>): Flow<T> = flow {
                 emit(it)
                 emit(it)
             }
             }
         }
         }
-
     } catch (e: CancellationException) {
     } catch (e: CancellationException) {
-        //ignore
+        // ignore
     }
     }
-}
+}

@@ -41,9 +41,9 @@ class TestCoroutineRule : TestRule {
             dispatcher.scheduler.advanceUntilIdle() // run the remaining tasks
             dispatcher.scheduler.advanceUntilIdle() // run the remaining tasks
             Assert.assertEquals(
             Assert.assertEquals(
                 timeAfterTest,
                 timeAfterTest,
-                dispatcher.scheduler.currentTime
+                dispatcher.scheduler.currentTime,
             ) // will fail if there were tasks scheduled at a later moment
             ) // will fail if there were tasks scheduled at a later moment
             Dispatchers.resetMain()
             Dispatchers.resetMain()
         }
         }
     }
     }
-}
+}

@@ -20,5 +20,5 @@ import kotlinx.coroutines.CoroutineScope
 
 
 class EventCollector<T : Event>(
 class EventCollector<T : Event>(
     eventListenable: EventListenable<T>,
     eventListenable: EventListenable<T>,
-    coroutineScope: CoroutineScope
-) : FlowCollector<T>(eventListenable.events, coroutineScope)
+    coroutineScope: CoroutineScope,
+) : FlowCollector<T>(eventListenable.events, coroutineScope)

@@ -25,7 +25,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
 
 
 open class FlowCollector<T>(
 open class FlowCollector<T>(
     private val flow: Flow<T>,
     private val flow: Flow<T>,
-    coroutineScope: CoroutineScope
+    coroutineScope: CoroutineScope,
 ) {
 ) {
     private val signal = MutableStateFlow<Unit?>(null)
     private val signal = MutableStateFlow<Unit?>(null)
     private val collectEventsDeferred = coroutineScope.async {
     private val collectEventsDeferred = coroutineScope.async {
@@ -40,5 +40,4 @@ open class FlowCollector<T>(
         signal.compareAndSet(null, Unit)
         signal.compareAndSet(null, Unit)
         return collectEventsDeferred.await()
         return collectEventsDeferred.await()
     }
     }
-
-}
+}

@@ -44,4 +44,4 @@ class MockAudioStreamTrack(
 
 
     override fun setVolume(volume: Double) {
     override fun setVolume(volume: Double) {
     }
     }
-}
+}

@@ -54,4 +54,4 @@ class MockDataChannel(private val label: String?) : DataChannel(1L) {
 
 
     override fun dispose() {
     override fun dispose() {
     }
     }
-}
+}

@@ -21,7 +21,7 @@ import android.view.Surface
 import org.webrtc.EglBase
 import org.webrtc.EglBase
 
 
 class MockEglBase(
 class MockEglBase(
-    private val eglContext: EglBase.Context = EglBase.Context { 0 }
+    private val eglContext: EglBase.Context = EglBase.Context { 0 },
 ) : EglBase {
 ) : EglBase {
 
 
     override fun createSurface(p0: Surface?) {}
     override fun createSurface(p0: Surface?) {}
@@ -51,4 +51,4 @@ class MockEglBase(
     override fun swapBuffers() {}
     override fun swapBuffers() {}
 
 
     override fun swapBuffers(p0: Long) {}
     override fun swapBuffers(p0: Long) {}
-}
+}

@@ -21,7 +21,7 @@ import org.webrtc.MediaStream
 import org.webrtc.VideoTrack
 import org.webrtc.VideoTrack
 
 
 fun createMediaStreamId(participantSid: String, trackSid: String) =
 fun createMediaStreamId(participantSid: String, trackSid: String) =
-    "${participantSid}|${trackSid}"
+    "$participantSid|$trackSid"
 
 
 class MockMediaStream(private val id: String = "id") : MediaStream(1L) {
 class MockMediaStream(private val id: String = "id") : MediaStream(1L) {
 
 
@@ -50,4 +50,4 @@ class MockMediaStream(private val id: String = "id") : MediaStream(1L) {
     }
     }
 
 
     override fun getId(): String = id
     override fun getId(): String = id
-}
+}

@@ -41,4 +41,4 @@ class MockMediaStreamTrack(
 
 
     override fun dispose() {
     override fun dispose() {
     }
     }
-}
+}

@@ -40,7 +40,7 @@ private class MockNativePeerConnectionFactory : NativePeerConnectionFactory {
 
 
 class MockPeerConnection(
 class MockPeerConnection(
     var rtcConfig: RTCConfiguration,
     var rtcConfig: RTCConfiguration,
-    val observer: Observer?
+    val observer: Observer?,
 ) : PeerConnection(MockNativePeerConnectionFactory()) {
 ) : PeerConnection(MockNativePeerConnectionFactory()) {
 
 
     private var closed = false
     private var closed = false
@@ -78,7 +78,6 @@ class MockPeerConnection(
         observer?.onCreateSuccess(sdp)
         observer?.onCreateSuccess(sdp)
     }
     }
 
 
-
     override fun setAudioPlayout(playout: Boolean) {
     override fun setAudioPlayout(playout: Boolean) {
     }
     }
 
 
@@ -142,7 +141,7 @@ class MockPeerConnection(
 
 
     override fun addTransceiver(
     override fun addTransceiver(
         track: MediaStreamTrack,
         track: MediaStreamTrack,
-        init: RtpTransceiver.RtpTransceiverInit?
+        init: RtpTransceiver.RtpTransceiverInit?,
     ): RtpTransceiver {
     ): RtpTransceiver {
         val transceiver = MockRtpTransceiver.create(track, init ?: RtpTransceiver.RtpTransceiverInit())
         val transceiver = MockRtpTransceiver.create(track, init ?: RtpTransceiver.RtpTransceiverInit())
         transceivers.add(transceiver)
         transceivers.add(transceiver)
@@ -155,7 +154,7 @@ class MockPeerConnection(
 
 
     override fun addTransceiver(
     override fun addTransceiver(
         mediaType: MediaStreamTrack.MediaType?,
         mediaType: MediaStreamTrack.MediaType?,
-        init: RtpTransceiver.RtpTransceiverInit?
+        init: RtpTransceiver.RtpTransceiverInit?,
     ): RtpTransceiver {
     ): RtpTransceiver {
         return super.addTransceiver(mediaType, init)
         return super.addTransceiver(mediaType, init)
     }
     }
@@ -187,9 +186,9 @@ class MockPeerConnection(
 
 
         if ((localDesc?.type == null && remoteDesc?.type == null) ||
         if ((localDesc?.type == null && remoteDesc?.type == null) ||
             (localDesc?.type == SessionDescription.Type.OFFER &&
             (localDesc?.type == SessionDescription.Type.OFFER &&
-                    remoteDesc?.type == SessionDescription.Type.ANSWER) ||
+                remoteDesc?.type == SessionDescription.Type.ANSWER) ||
             (localDesc?.type == SessionDescription.Type.ANSWER &&
             (localDesc?.type == SessionDescription.Type.ANSWER &&
-                    remoteDesc?.type == SessionDescription.Type.OFFER)
+                remoteDesc?.type == SessionDescription.Type.OFFER)
         ) {
         ) {
             return SignalingState.STABLE
             return SignalingState.STABLE
         }
         }
@@ -281,4 +280,4 @@ class MockPeerConnection(
     }
     }
 
 
     override fun getNativePeerConnection(): Long = 0L
     override fun getNativePeerConnection(): Long = 0L
-}
+}

@@ -23,4 +23,4 @@ object MockRtpReceiver {
     fun create(): RtpReceiver {
     fun create(): RtpReceiver {
         return Mockito.mock(RtpReceiver::class.java)
         return Mockito.mock(RtpReceiver::class.java)
     }
     }
-}
+}