Separate adjustable logging levels

@@ -4,9 +4,28 @@ import android.content.Context
 import io.livekit.android.dagger.DaggerLiveKitComponent
 import io.livekit.android.room.Room
 import io.livekit.android.room.RoomListener
+import io.livekit.android.util.LKLog
+import io.livekit.android.util.LoggingLevel
+import timber.log.Timber
 
 class LiveKit {
     companion object {
+        var loggingLevel: LoggingLevel
+            get() = LKLog.loggingLevel
+            set(value) {
+                LKLog.loggingLevel = value
+
+                // Plant debug tree if needed.
+                if (value != LoggingLevel.OFF) {
+                    val forest = Timber.forest()
+                    val needsPlanting = forest.none { it is Timber.DebugTree }
+
+                    if (needsPlanting) {
+                        Timber.plant(Timber.DebugTree())
+                    }
+                }
+            }
+
         /**
          * Connect to a LiveKit room
          * @param url URL to LiveKit server (i.e. ws://mylivekitdeploy.io)

 package io.livekit.android.dagger
 
 import android.content.Context
-import com.github.ajalt.timberkt.Timber
 import dagger.Module
 import dagger.Provides
+import io.livekit.android.util.LKLog
 import org.webrtc.*
 import org.webrtc.audio.AudioDeviceModule
 import org.webrtc.audio.JavaAudioDeviceModule
@@ -21,46 +21,46 @@ class RTCModule {
             // Set audio record error callbacks.
             val audioRecordErrorCallback = object : JavaAudioDeviceModule.AudioRecordErrorCallback {
                 override fun onWebRtcAudioRecordInitError(errorMessage: String?) {
-                    Timber.e { "onWebRtcAudioRecordInitError: $errorMessage" }
+                    LKLog.e { "onWebRtcAudioRecordInitError: $errorMessage" }
                 }
 
                 override fun onWebRtcAudioRecordStartError(
                     errorCode: JavaAudioDeviceModule.AudioRecordStartErrorCode?,
                     errorMessage: String?
                 ) {
-                    Timber.e { "onWebRtcAudioRecordStartError: $errorCode. $errorMessage" }
+                    LKLog.e { "onWebRtcAudioRecordStartError: $errorCode. $errorMessage" }
                 }
 
                 override fun onWebRtcAudioRecordError(errorMessage: String?) {
-                    Timber.e { "onWebRtcAudioRecordError: $errorMessage" }
+                    LKLog.e { "onWebRtcAudioRecordError: $errorMessage" }
                 }
             }
 
             val audioTrackErrorCallback = object : JavaAudioDeviceModule.AudioTrackErrorCallback {
                 override fun onWebRtcAudioTrackInitError(errorMessage: String?) {
-                    Timber.e { "onWebRtcAudioTrackInitError: $errorMessage" }
+                    LKLog.e { "onWebRtcAudioTrackInitError: $errorMessage" }
                 }
 
                 override fun onWebRtcAudioTrackStartError(
                     errorCode: JavaAudioDeviceModule.AudioTrackStartErrorCode?,
                     errorMessage: String?
                 ) {
-                    Timber.e { "onWebRtcAudioTrackStartError: $errorCode. $errorMessage" }
+                    LKLog.e { "onWebRtcAudioTrackStartError: $errorCode. $errorMessage" }
                 }
 
                 override fun onWebRtcAudioTrackError(errorMessage: String?) {
-                    Timber.e { "onWebRtcAudioTrackError: $errorMessage" }
+                    LKLog.e { "onWebRtcAudioTrackError: $errorMessage" }
                 }
 
             }
             val audioRecordStateCallback: JavaAudioDeviceModule.AudioRecordStateCallback = object :
                 JavaAudioDeviceModule.AudioRecordStateCallback {
                 override fun onWebRtcAudioRecordStart() {
-                    Timber.i { "Audio recording starts" }
+                    LKLog.i { "Audio recording starts" }
                 }
 
                 override fun onWebRtcAudioRecordStop() {
-                    Timber.i { "Audio recording stops" }
+                    LKLog.i { "Audio recording stops" }
                 }
             }
 
@@ -68,11 +68,11 @@ class RTCModule {
             val audioTrackStateCallback: JavaAudioDeviceModule.AudioTrackStateCallback = object :
                 JavaAudioDeviceModule.AudioTrackStateCallback {
                 override fun onWebRtcAudioTrackStart() {
-                    Timber.i { "Audio playout starts" }
+                    LKLog.i { "Audio playout starts" }
                 }
 
                 override fun onWebRtcAudioTrackStop() {
-                    Timber.i { "Audio playout stops" }
+                    LKLog.i { "Audio playout stops" }
                 }
             }
 

 package io.livekit.android.room
 
-import com.github.ajalt.timberkt.Timber
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import io.livekit.android.dagger.InjectionNames
 import io.livekit.android.room.util.*
 import io.livekit.android.util.Either
+import io.livekit.android.util.LKLog
 import io.livekit.android.util.debounce
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
@@ -77,7 +77,7 @@ constructor(
         val iceRestart =
             constraints.findConstraint(MediaConstraintKeys.ICE_RESTART) == MediaConstraintKeys.TRUE
         if (iceRestart) {
-            Timber.d { "restarting ice" }
+            LKLog.d { "restarting ice" }
             restartingIce = true
         }
 
@@ -96,16 +96,16 @@ constructor(
         }
 
         // actually negotiate
-        Timber.d { "starting to negotiate" }
+        LKLog.d { "starting to negotiate" }
         val sdpOffer = when (val outcome = peerConnection.createOffer(constraints)) {
             is Either.Left -> outcome.value
             is Either.Right -> {
-                Timber.d { "error creating offer: ${outcome.value}" }
+                LKLog.d { "error creating offer: ${outcome.value}" }
                 return
             }
         }
 
-        Timber.v { "sdp offer = $sdpOffer, description: ${sdpOffer.description}, type: ${sdpOffer.type}" }
+        LKLog.v { "sdp offer = $sdpOffer, description: ${sdpOffer.description}, type: ${sdpOffer.type}" }
         peerConnection.setLocalDescription(sdpOffer)
         listener?.onOffer(sdpOffer)
     }

 package io.livekit.android.room
 
-import com.github.ajalt.timberkt.Timber
+import io.livekit.android.util.LKLog
 import livekit.LivekitRtc
 import org.webrtc.*
 
@@ -18,7 +18,7 @@ class PublisherTransportObserver(
 
     override fun onIceCandidate(iceCandidate: IceCandidate?) {
         val candidate = iceCandidate ?: return
-        Timber.v { "onIceCandidate: $candidate" }
+        LKLog.v { "onIceCandidate: $candidate" }
         client.sendCandidate(candidate, target = LivekitRtc.SignalTarget.PUBLISHER)
     }
 
@@ -27,7 +27,7 @@ class PublisherTransportObserver(
     }
 
     override fun onIceConnectionChange(newState: PeerConnection.IceConnectionState?) {
-        Timber.v { "onIceConnection new state: $newState" }
+        LKLog.v { "onIceConnection new state: $newState" }
         iceConnectionChangeListener?.invoke(newState)
     }
 

 package io.livekit.android.room
 
 import android.os.SystemClock
-import com.github.ajalt.timberkt.Timber
 import io.livekit.android.ConnectOptions
 import io.livekit.android.dagger.InjectionNames
 import io.livekit.android.room.track.DataPublishReliability
@@ -11,6 +10,7 @@ import io.livekit.android.room.track.TrackPublication
 import io.livekit.android.room.util.*
 import io.livekit.android.util.CloseableCoroutineScope
 import io.livekit.android.util.Either
+import io.livekit.android.util.LKLog
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
@@ -50,15 +50,15 @@ internal constructor(
             when (value) {
                 IceState.CONNECTED -> {
                     if (oldVal == IceState.DISCONNECTED) {
-                        Timber.d { "publisher ICE connected" }
+                        LKLog.d { "publisher ICE connected" }
                         listener?.onIceConnected()
                     } else if (oldVal == IceState.RECONNECTING) {
-                        Timber.d { "publisher ICE reconnected" }
+                        LKLog.d { "publisher ICE reconnected" }
                         listener?.onIceReconnected()
                     }
                 }
                 IceState.DISCONNECTED -> {
-                    Timber.d { "publisher ICE disconnected" }
+                    LKLog.d { "publisher ICE disconnected" }
                     listener?.onDisconnect("Peer connection disconnected")
                 }
                 else -> {
@@ -133,11 +133,11 @@ internal constructor(
             iceServers.addAll(SignalClient.DEFAULT_ICE_SERVERS)
         }
         joinResponse.iceServersList.forEach {
-            Timber.v { "username = \"${it.username}\"" }
-            Timber.v { "credential = \"${it.credential}\"" }
-            Timber.v { "urls: " }
+            LKLog.v { "username = \"${it.username}\"" }
+            LKLog.v { "credential = \"${it.credential}\"" }
+            LKLog.v { "urls: " }
             it.urlsList.forEach {
-                Timber.v { "   $it" }
+                LKLog.v { "   $it" }
             }
         }
 
@@ -162,7 +162,7 @@ internal constructor(
         val iceConnectionStateListener: (PeerConnection.IceConnectionState?) -> Unit = { newState ->
             val state =
                 newState ?: throw NullPointerException("unexpected null new state, what do?")
-            Timber.v { "onIceConnection new state: $newState" }
+            LKLog.v { "onIceConnection new state: $newState" }
             if (state == PeerConnection.IceConnectionState.CONNECTED) {
                 iceState = IceState.CONNECTED
             } else if (state == PeerConnection.IceConnectionState.FAILED) {
@@ -242,11 +242,11 @@ internal constructor(
         val url = sessionUrl
         val token = sessionToken
         if (url == null || token == null) {
-            Timber.w { "couldn't reconnect, no url or no token" }
+            LKLog.w { "couldn't reconnect, no url or no token" }
             return
         }
         if (iceState == IceState.DISCONNECTED || wsRetries >= MAX_SIGNAL_RETRIES) {
-            Timber.w { "could not connect to signal after max attempts, giving up" }
+            LKLog.w { "could not connect to signal after max attempts, giving up" }
             close()
             listener?.onDisconnect("could not reconnect after limit")
             return
@@ -259,13 +259,13 @@ internal constructor(
         coroutineScope.launch {
             delay(startDelay)
             if (iceState == IceState.DISCONNECTED) {
-                Timber.e { "Ice is disconnected" }
+                LKLog.e { "Ice is disconnected" }
                 return@launch
             }
 
             client.reconnect(url, token)
 
-            Timber.v { "reconnected, restarting ICE" }
+            LKLog.v { "reconnected, restarting ICE" }
             wsRetries = 0
 
             // trigger publisher reconnect
@@ -396,9 +396,9 @@ internal constructor(
     //---------------------------------- SignalClient.Listener --------------------------------------//
 
     override fun onAnswer(sessionDescription: SessionDescription) {
-        Timber.v { "received server answer: ${sessionDescription.type}, ${publisher.peerConnection.signalingState()}" }
+        LKLog.v { "received server answer: ${sessionDescription.type}, ${publisher.peerConnection.signalingState()}" }
         coroutineScope.launch {
-            Timber.i { sessionDescription.toString() }
+            LKLog.i { sessionDescription.toString() }
             when (val outcome = publisher.setRemoteDescription(sessionDescription)) {
                 is Either.Left -> {
                     // when reconnecting, ICE might not have disconnected and won't trigger
@@ -408,20 +408,20 @@ internal constructor(
                     }
                 }
                 is Either.Right -> {
-                    Timber.e { "error setting remote description for answer: ${outcome.value} " }
+                    LKLog.e { "error setting remote description for answer: ${outcome.value} " }
                 }
             }
         }
     }
 
     override fun onOffer(sessionDescription: SessionDescription) {
-        Timber.v { "received server offer: ${sessionDescription.type}, ${subscriber.peerConnection.signalingState()}" }
+        LKLog.v { "received server offer: ${sessionDescription.type}, ${subscriber.peerConnection.signalingState()}" }
         coroutineScope.launch {
             run<Unit> {
                 when (val outcome =
                     subscriber.setRemoteDescription(sessionDescription)) {
                     is Either.Right -> {
-                        Timber.e { "error setting remote description for answer: ${outcome.value} " }
+                        LKLog.e { "error setting remote description for answer: ${outcome.value} " }
                         return@launch
                     }
                 }
@@ -431,7 +431,7 @@ internal constructor(
                 when (val outcome = subscriber.peerConnection.createAnswer(MediaConstraints())) {
                     is Either.Left -> outcome.value
                     is Either.Right -> {
-                        Timber.e { "error creating answer: ${outcome.value}" }
+                        LKLog.e { "error creating answer: ${outcome.value}" }
                         return@launch
                     }
                 }
@@ -440,7 +440,7 @@ internal constructor(
             run<Unit> {
                 when (val outcome = subscriber.peerConnection.setLocalDescription(answer)) {
                     is Either.Right -> {
-                        Timber.e { "error setting local description for answer: ${outcome.value}" }
+                        LKLog.e { "error setting local description for answer: ${outcome.value}" }
                         return@launch
                     }
                 }
@@ -451,29 +451,29 @@ internal constructor(
     }
 
     override fun onTrickle(candidate: IceCandidate, target: LivekitRtc.SignalTarget) {
-        Timber.v { "received ice candidate from peer: $candidate, $target" }
+        LKLog.v { "received ice candidate from peer: $candidate, $target" }
         when (target) {
             LivekitRtc.SignalTarget.PUBLISHER -> publisher.addIceCandidate(candidate)
             LivekitRtc.SignalTarget.SUBSCRIBER -> subscriber.addIceCandidate(candidate)
-            else -> Timber.i { "unknown ice candidate target?" }
+            else -> LKLog.i { "unknown ice candidate target?" }
         }
     }
 
     override fun onLocalTrackPublished(response: LivekitRtc.TrackPublishedResponse) {
         val cid = response.cid ?: run {
-            Timber.e { "local track published with null cid?" }
+            LKLog.e { "local track published with null cid?" }
             return
         }
 
         val track = response.track
         if (track == null) {
-            Timber.d { "local track published with null track info?" }
+            LKLog.d { "local track published with null track info?" }
         }
 
-        Timber.v { "local track published $cid" }
+        LKLog.v { "local track published $cid" }
         val cont = pendingTrackResolvers.remove(cid)
         if (cont == null) {
-            Timber.d { "missing track resolver for: $cid" }
+            LKLog.d { "missing track resolver for: $cid" }
             return
         }
         cont.resume(response.track)
@@ -489,7 +489,7 @@ internal constructor(
 
     override fun onClose(reason: String, code: Int) {
         // TODO: reconnect logic
-        Timber.i { "received close event: $reason, code: $code" }
+        LKLog.i { "received close event: $reason, code: $code" }
         listener?.onDisconnect(reason)
     }
 
@@ -528,7 +528,7 @@ internal constructor(
             }
             LivekitModels.DataPacket.ValueCase.VALUE_NOT_SET,
             null -> {
-                Timber.v { "invalid value for data packet" }
+                LKLog.v { "invalid value for data packet" }
             }
         }
     }

@@ -5,7 +5,6 @@ import android.net.ConnectivityManager
 import android.net.Network
 import android.net.NetworkCapabilities
 import android.net.NetworkRequest
-import com.github.ajalt.timberkt.Timber
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
@@ -17,6 +16,7 @@ import io.livekit.android.room.participant.Participant
 import io.livekit.android.room.participant.ParticipantListener
 import io.livekit.android.room.participant.RemoteParticipant
 import io.livekit.android.room.track.*
+import io.livekit.android.util.LKLog
 import livekit.LivekitModels
 import livekit.LivekitRtc
 import org.webrtc.*
@@ -68,7 +68,7 @@ constructor(
     suspend fun connect(url: String, token: String, options: ConnectOptions?) {
         state = State.CONNECTING
         val response = engine.join(url, token, options)
-        Timber.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)
         name = response.room.name
@@ -249,7 +249,7 @@ constructor(
         if (!hasLostConnectivity) {
             return
         }
-        Timber.i { "network connection available, reconnecting" }
+        LKLog.i { "network connection available, reconnecting" }
         reconnect()
         hasLostConnectivity = false
     }
@@ -270,7 +270,7 @@ constructor(
      */
     override fun onAddTrack(track: MediaStreamTrack, streams: Array<out MediaStream>) {
         if (streams.count() < 0) {
-            Timber.i { "add track with empty streams?" }
+            LKLog.i { "add track with empty streams?" }
             return
         }
 
@@ -340,7 +340,7 @@ constructor(
      * @suppress
      */
     override fun onDisconnect(reason: String) {
-        Timber.v { "engine did disconnect: $reason" }
+        LKLog.v { "engine did disconnect: $reason" }
         handleDisconnect()
     }
 

 package io.livekit.android.room
 
-import com.github.ajalt.timberkt.Timber
 import com.google.protobuf.util.JsonFormat
 import io.livekit.android.ConnectOptions
 import io.livekit.android.Version
 import io.livekit.android.dagger.InjectionNames
 import io.livekit.android.room.track.Track
 import io.livekit.android.util.Either
+import io.livekit.android.util.LKLog
 import io.livekit.android.util.safe
 import kotlinx.coroutines.CancellableContinuation
 import kotlinx.coroutines.suspendCancellableCoroutine
@@ -92,7 +92,7 @@ constructor(
             }
         }
 
-        Timber.i { "connecting to $wsUrlString" }
+        LKLog.i { "connecting to $wsUrlString" }
 
         isConnected = false
         currentWs?.cancel()
@@ -124,7 +124,7 @@ constructor(
     }
 
     override fun onMessage(webSocket: WebSocket, text: String) {
-        Timber.v { text }
+        LKLog.v { text }
         val signalResponseBuilder = LivekitRtc.SignalResponse.newBuilder()
         fromJsonProtobuf.merge(text, signalResponseBuilder)
         val response = signalResponseBuilder.build()
@@ -142,13 +142,13 @@ constructor(
     }
 
     override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
-        Timber.v { "websocket closed" }
+        LKLog.v { "websocket closed" }
 
         listener?.onClose(reason, code)
     }
 
     override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
-        Timber.v { "websocket closing" }
+        LKLog.v { "websocket closing" }
     }
 
     override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
@@ -165,14 +165,14 @@ constructor(
                 }
             }
         } catch (e: Throwable) {
-            Timber.e(e) { "failed to validate connection" }
+            LKLog.e(e) { "failed to validate connection" }
         }
 
         if (reason != null) {
-            Timber.e(t) { "websocket failure: $reason" }
+            LKLog.e(t) { "websocket failure: $reason" }
             listener?.onError(Exception(reason))
         } else {
-            Timber.e(t) { "websocket failure: $response" }
+            LKLog.e(t) { "websocket failure: $response" }
             listener?.onError(t as Exception)
         }
     }
@@ -302,9 +302,9 @@ constructor(
     }
 
     private fun sendRequest(request: LivekitRtc.SignalRequest) {
-        Timber.v { "sending request: $request" }
+        LKLog.v { "sending request: $request" }
         if (!isConnected || currentWs == null) {
-            Timber.w { "not connected, could not send request $request" }
+            LKLog.w { "not connected, could not send request $request" }
             return
         }
         val sent: Boolean
@@ -317,7 +317,7 @@ constructor(
         }
 
         if (!sent) {
-            Timber.e { "error sending request: $request" }
+            LKLog.e { "error sending request: $request" }
         }
     }
 
@@ -328,12 +328,12 @@ constructor(
                 isConnected = true
                 joinContinuation?.resumeWith(Result.success(Either.Left(response.join)))
             } else {
-                Timber.e { "Received response while not connected. ${toJsonProtobuf.print(response)}" }
+                LKLog.e { "Received response while not connected. ${toJsonProtobuf.print(response)}" }
             }
             return
         }
 
-        Timber.v { "response: $response" }
+        LKLog.v { "response: $response" }
         when (response.messageCase) {
             LivekitRtc.SignalResponse.MessageCase.ANSWER -> {
                 val sd = fromProtoSessionDescription(response.answer)
@@ -363,7 +363,7 @@ constructor(
                 listener?.onSpeakersChanged(response.speakersChanged.speakersList)
             }
             LivekitRtc.SignalResponse.MessageCase.JOIN -> {
-                Timber.d { "received unexpected extra join message?" }
+                LKLog.d { "received unexpected extra join message?" }
             }
             LivekitRtc.SignalResponse.MessageCase.LEAVE -> {
                 listener?.onLeave()
@@ -376,7 +376,7 @@ constructor(
             }
             LivekitRtc.SignalResponse.MessageCase.MESSAGE_NOT_SET,
             null -> {
-                Timber.v { "empty messageCase!" }
+                LKLog.v { "empty messageCase!" }
             }
         }.safe()
     }

 package io.livekit.android.room
 
-import com.github.ajalt.timberkt.Timber
+import io.livekit.android.util.LKLog
 import livekit.LivekitRtc
 import org.webrtc.*
 
@@ -15,33 +15,33 @@ class SubscriberTransportObserver(
     var iceConnectionChangeListener: ((PeerConnection.IceConnectionState?) -> Unit)? = null
 
     override fun onIceCandidate(candidate: IceCandidate) {
-        Timber.v { "onIceCandidate: $candidate" }
+        LKLog.v { "onIceCandidate: $candidate" }
         client.sendCandidate(candidate, LivekitRtc.SignalTarget.SUBSCRIBER)
     }
 
     override fun onAddTrack(receiver: RtpReceiver, streams: Array<out MediaStream>) {
         val track = receiver.track() ?: return
-        Timber.v { "onAddTrack: ${track.kind()}, ${track.id()}, ${streams.fold("") { sum, it -> "$sum, $it" }}" }
+        LKLog.v { "onAddTrack: ${track.kind()}, ${track.id()}, ${streams.fold("") { sum, it -> "$sum, $it" }}" }
         engine.listener?.onAddTrack(track, streams)
     }
 
     override fun onTrack(transceiver: RtpTransceiver) {
         when (transceiver.mediaType) {
-            MediaStreamTrack.MediaType.MEDIA_TYPE_AUDIO -> Timber.v { "peerconn started receiving audio" }
-            MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO -> Timber.v { "peerconn started receiving video" }
-            else -> Timber.d { "peerconn started receiving unknown media type: ${transceiver.mediaType}" }
+            MediaStreamTrack.MediaType.MEDIA_TYPE_AUDIO -> LKLog.v { "peerconn started receiving audio" }
+            MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO -> LKLog.v { "peerconn started receiving video" }
+            else -> LKLog.d { "peerconn started receiving unknown media type: ${transceiver.mediaType}" }
         }
     }
 
     override fun onDataChannel(channel: DataChannel) {
-        Timber.v { "onDataChannel" }
+        LKLog.v { "onDataChannel" }
     }
 
     override fun onStandardizedIceConnectionChange(newState: PeerConnection.IceConnectionState?) {
     }
 
     override fun onConnectionChange(newState: PeerConnection.PeerConnectionState?) {
-        Timber.v { "onConnectionChange new state: $newState" }
+        LKLog.v { "onConnectionChange new state: $newState" }
     }
 
     override fun onSelectedCandidatePairChanged(event: CandidatePairChangeEvent?) {
@@ -51,7 +51,7 @@ class SubscriberTransportObserver(
     }
 
     override fun onIceConnectionChange(newState: PeerConnection.IceConnectionState?) {
-        Timber.v { "onIceConnection new state: $newState" }
+        LKLog.v { "onIceConnection new state: $newState" }
         iceConnectionChangeListener?.invoke(newState)
     }
 

 package io.livekit.android.room.participant
 
 import android.content.Context
-import com.github.ajalt.timberkt.Timber
 import com.google.protobuf.ByteString
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import io.livekit.android.room.RTCEngine
 import io.livekit.android.room.track.*
+import io.livekit.android.util.LKLog
 import livekit.LivekitModels
 import livekit.LivekitRtc
 import org.webrtc.*
@@ -124,7 +124,7 @@ internal constructor(
     fun unpublishTrack(track: Track) {
         val publication = localTrackPublications.firstOrNull { it.track == track }
         if (publication === null) {
-            Timber.d { "this track was never published." }
+            LKLog.d { "this track was never published." }
             return
         }
         val sid = publication.sid

 package io.livekit.android.room.participant
 
-import com.github.ajalt.timberkt.Timber
 import io.livekit.android.room.SignalClient
 import io.livekit.android.room.track.*
 import io.livekit.android.util.CloseableCoroutineScope
+import io.livekit.android.util.LKLog
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -83,7 +83,7 @@ class RemoteParticipant(
             if (triesLeft == 0) {
                 val message = "Could not find published track with sid: $sid"
                 val exception = TrackException.InvalidTrackStateException(message)
-                Timber.e { "remote participant ${this.sid} --- $message" }
+                LKLog.e { "remote participant ${this.sid} --- $message" }
 
                 internalListener?.onTrackSubscriptionFailed(sid, exception, this)
                 listener?.onTrackSubscriptionFailed(sid, exception, this)

 package io.livekit.android.room.track
 
 import android.content.Context
-import com.github.ajalt.timberkt.Timber
+import io.livekit.android.util.LKLog
 import org.webrtc.*
 import java.util.*
 
@@ -114,7 +114,7 @@ class LocalVideoTrack(
                 createCameraCapturer(Camera1Enumerator(true), position)
             }
             if (videoCapturer == null) {
-                Timber.d { "Failed to open camera" }
+                LKLog.d { "Failed to open camera" }
                 return null
             }
             return videoCapturer
@@ -125,13 +125,13 @@ class LocalVideoTrack(
 
             for (deviceName in deviceNames) {
                 if (enumerator.isFrontFacing(deviceName) && position == CameraPosition.FRONT) {
-                    Timber.v { "Creating front facing camera capturer." }
+                    LKLog.v { "Creating front facing camera capturer." }
                     val videoCapturer = enumerator.createCapturer(deviceName, null)
                     if (videoCapturer != null) {
                         return videoCapturer
                     }
                 } else if (enumerator.isBackFacing(deviceName) && position == CameraPosition.BACK) {
-                    Timber.v { "Creating back facing camera capturer." }
+                    LKLog.v { "Creating back facing camera capturer." }
                     val videoCapturer = enumerator.createCapturer(deviceName, null)
                     if (videoCapturer != null) {
                         return videoCapturer

+package io.livekit.android.util
+
+import io.livekit.android.util.LoggingLevel.*
+import timber.log.Timber
+
+/*
+Copyright 2017-2018 AJ Alt
+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.
+
+Original repo can be found at: https://github.com/ajalt/LKLogkt
+ */
+
+internal class LKLog {
+
+    companion object {
+        var loggingLevel = OFF
+
+
+        /** Log a verbose exception and a message that will be evaluated lazily when the message is printed */
+        @JvmStatic
+        inline fun v(t: Throwable? = null, message: () -> String) =
+            log(VERBOSE) { Timber.v(t, message()) }
+
+        @JvmStatic
+        inline fun v(t: Throwable?) = log(VERBOSE) { Timber.v(t) }
+
+        /** Log a debug exception and a message that will be evaluated lazily when the message is printed */
+        @JvmStatic
+        inline fun d(t: Throwable? = null, message: () -> String) =
+            log(DEBUG) { Timber.d(t, message()) }
+
+        @JvmStatic
+        inline fun d(t: Throwable?) = log(DEBUG) { Timber.d(t) }
+
+        /** Log an info exception and a message that will be evaluated lazily when the message is printed */
+        @JvmStatic
+        inline fun i(t: Throwable? = null, message: () -> String) =
+            log(INFO) { Timber.i(t, message()) }
+
+        @JvmStatic
+        inline fun i(t: Throwable?) = log(INFO) { Timber.i(t) }
+
+        /** Log a warning exception and a message that will be evaluated lazily when the message is printed */
+        @JvmStatic
+        inline fun w(t: Throwable? = null, message: () -> String) =
+            log(WARN) { Timber.w(t, message()) }
+
+        @JvmStatic
+        inline fun w(t: Throwable?) = log(WARN) { Timber.w(t) }
+
+        /** Log an error exception and a message that will be evaluated lazily when the message is printed */
+        @JvmStatic
+        inline fun e(t: Throwable? = null, message: () -> String) =
+            log(ERROR) { Timber.e(t, message()) }
+
+        @JvmStatic
+        inline fun e(t: Throwable?) = log(ERROR) { Timber.e(t) }
+
+        /** Log an assert exception and a message that will be evaluated lazily when the message is printed */
+        @JvmStatic
+        inline fun wtf(t: Throwable? = null, message: () -> String) =
+            log(WTF) { Timber.wtf(t, message()) }
+
+        @JvmStatic
+        inline fun wtf(t: Throwable?) = log(WTF) { Timber.wtf(t) }
+
+        /** @suppress */
+        internal inline fun log(loggingLevel: LoggingLevel, block: () -> Unit) {
+            if (loggingLevel >= LKLog.loggingLevel && Timber.treeCount() > 0) block()
+        }
+    }
+}

+package io.livekit.android.util
+enum class LoggingLevel {
+    VERBOSE,
+    INFO,
+    DEBUG,
+    WARN,
+    ERROR,
+    WTF,
+    OFF,
+}
\ No newline at end of file

 package io.livekit.android.composesample
 
 import android.app.Application
-import timber.log.Timber
+import io.livekit.android.LiveKit
+import io.livekit.android.util.LoggingLevel
 
 class SampleApplication : Application() {
 
     override fun onCreate() {
         super.onCreate()
-        Timber.plant(Timber.DebugTree())
+        LiveKit.loggingLevel = LoggingLevel.OFF
     }
 }
\ No newline at end of file

 package io.livekit.android.sample
 
 import android.app.Application
-import timber.log.Timber
+import io.livekit.android.LiveKit
+import io.livekit.android.util.LoggingLevel
 
 class SampleApplication : Application() {
 
     override fun onCreate() {
         super.onCreate()
-        Timber.plant(Timber.DebugTree())
+        LiveKit.loggingLevel = LoggingLevel.VERBOSE
     }
 }
\ No newline at end of file