Merge pull request #546 from vector-im/feature/cleanup

Cleanup

CHANGES.md

@@ -12,6 +12,7 @@ Other changes:
 
 Bugfix:
  - Fix crash due to missing informationData (#535)
+ - Progress in initial sync dialog is decreasing for a step and should not (#532)
 
 Translations:
  -

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/pushrules/RoomMemberCountCondition.kt

@@ -21,14 +21,14 @@ import timber.log.Timber
 
 private val regex = Regex("^(==|<=|>=|<|>)?(\\d*)$")
 
-class RoomMemberCountCondition(val `is`: String) : Condition(Kind.room_member_count) {
+class RoomMemberCountCondition(val iz: String) : Condition(Kind.room_member_count) {
 
     override fun isSatisfied(conditionResolver: ConditionResolver): Boolean {
         return conditionResolver.resolveRoomMemberCountCondition(this)
     }
 
     override fun technicalDescription(): String {
-        return "Room member count is $`is`"
+        return "Room member count is $iz"
     }
 
     fun isSatisfied(event: Event, session: RoomService?): Boolean {
@@ -55,7 +55,7 @@ class RoomMemberCountCondition(val `is`: String) : Condition(Kind.room_member_co
      */
     private fun parseIsField(): Pair<String?, Int>? {
         try {
-            val match = regex.find(`is`) ?: return null
+            val match = regex.find(iz) ?: return null
             val (prefix, count) = match.destructured
             return prefix to count.toInt()
         } catch (t: Throwable) {

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/InitialSyncProgressService.kt

@@ -20,10 +20,10 @@ import androidx.lifecycle.LiveData
 
 interface InitialSyncProgressService {
 
-    fun getLiveStatus() : LiveData<Status?>
+    fun getInitialSyncProgressStatus() : LiveData<Status?>
 
     data class Status(
-            @StringRes val statusText: Int?,
+            @StringRes val statusText: Int,
             val percentProgress: Int = 0
     )
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/CryptoModule.kt

@@ -105,7 +105,7 @@ internal abstract class CryptoModule {
     }
 
     @Binds
-    abstract fun bindCryptoService(cryptoManager: CryptoManager): CryptoService
+    abstract fun bindCryptoService(cryptoService: DefaultCryptoService): CryptoService
 
     @Binds
     abstract fun bindDeleteDeviceTask(deleteDeviceTask: DefaultDeleteDeviceTask): DeleteDeviceTask

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/DefaultCryptoService.kt

@@ -93,7 +93,7 @@ import kotlin.math.max
  * Specially, it tracks all room membership changes events in order to do keys updates.
  */
 @SessionScope
-internal class CryptoManager @Inject constructor(
+internal class DefaultCryptoService @Inject constructor(
         // Olm Manager
         private val olmManager: OlmManager,
         // The credentials,
@@ -1067,6 +1067,6 @@ internal class CryptoManager @Inject constructor(
      * ========================================================================================== */
 
     override fun toString(): String {
-        return "CryptoManager of " + credentials.userId + " (" + credentials.deviceId + ")"
+        return "DefaultCryptoService of " + credentials.userId + " (" + credentials.deviceId + ")"
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackup.kt

@@ -67,7 +67,6 @@ import org.matrix.olm.OlmPkMessage
 import timber.log.Timber
 import java.security.InvalidParameterException
 import javax.inject.Inject
-import kotlin.collections.HashMap
 import kotlin.random.Random
 
 /**
@@ -846,7 +845,7 @@ internal class KeysBackup @Inject constructor(
                 // Wait between 0 and 10 seconds, to avoid backup requests from
                 // different clients hitting the server all at the same time when a
                 // new key is sent
-                val delayInMs = Random.nextInt(KEY_BACKUP_WAITING_TIME_TO_SEND_KEY_BACKUP_MILLIS).toLong()
+                val delayInMs = Random.nextLong(KEY_BACKUP_WAITING_TIME_TO_SEND_KEY_BACKUP_MILLIS)
 
                 uiHandler.postDelayed({ backupKeys() }, delayInMs)
             }
@@ -1403,7 +1402,7 @@ internal class KeysBackup @Inject constructor(
 
     companion object {
         // Maximum delay in ms in {@link maybeBackupKeys}
-        private const val KEY_BACKUP_WAITING_TIME_TO_SEND_KEY_BACKUP_MILLIS = 10000
+        private const val KEY_BACKUP_WAITING_TIME_TO_SEND_KEY_BACKUP_MILLIS = 10_000L
 
         // Maximum number of keys to send at a time to the homeserver.
         private const val KEY_BACKUP_SEND_KEYS_MAX_COUNT = 100

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/DefaultInitialSyncProgressService.kt

@@ -15,6 +15,7 @@
  */
 package im.vector.matrix.android.internal.session
 
+import androidx.annotation.StringRes
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
 import im.vector.matrix.android.api.session.InitialSyncProgressService
@@ -25,31 +26,33 @@ import javax.inject.Inject
 @SessionScope
 class DefaultInitialSyncProgressService @Inject constructor() : InitialSyncProgressService {
 
-    var status = MutableLiveData<InitialSyncProgressService.Status>()
+    private var status = MutableLiveData<InitialSyncProgressService.Status>()
 
-    var rootTask: TaskInfo? = null
+    private var rootTask: TaskInfo? = null
 
-    override fun getLiveStatus(): LiveData<InitialSyncProgressService.Status?> {
+    override fun getInitialSyncProgressStatus(): LiveData<InitialSyncProgressService.Status?> {
         return status
     }
 
-
+    fun startTask(@StringRes nameRes: Int, totalProgress: Int, parentWeight: Float = 1f) {
-    fun startTask(nameRes: Int, totalProgress: Int, parentWeight: Float = 1f) {
+        // Create a rootTask, or add a child to the leaf
         if (rootTask == null) {
             rootTask = TaskInfo(nameRes, totalProgress)
         } else {
             val currentLeaf = rootTask!!.leaf()
-            val newTask = TaskInfo(nameRes, totalProgress)
+
-            newTask.parent = currentLeaf
+            val newTask = TaskInfo(nameRes,
-            newTask.offset = currentLeaf.currentProgress
+                    totalProgress,
+                    currentLeaf,
+                    parentWeight)
+
             currentLeaf.child = newTask
-            newTask.parentWeight = parentWeight
         }
         reportProgress(0)
     }
 
     fun reportProgress(progress: Int) {
-        rootTask?.leaf()?.incrementProgress(progress)
+        rootTask?.leaf()?.setProgress(progress)
     }
 
     fun endTask(nameRes: Int) {
@@ -58,7 +61,7 @@ class DefaultInitialSyncProgressService @Inject constructor() : InitialSyncProgr
             //close it
             val parent = endedTask.parent
             parent?.child = null
-            parent?.incrementProgress(endedTask.offset + (endedTask.totalProgress * endedTask.parentWeight).toInt())
+            parent?.setProgress(endedTask.offset + (endedTask.totalProgress * endedTask.parentWeight).toInt())
         }
         if (endedTask?.parent == null) {
             status.postValue(null)
@@ -71,14 +74,17 @@ class DefaultInitialSyncProgressService @Inject constructor() : InitialSyncProgr
     }
 
 
-    inner class TaskInfo(var nameRes: Int,
+    private inner class TaskInfo(@StringRes var nameRes: Int,
-                         var totalProgress: Int) {
+                                 var totalProgress: Int,
-        var parent: TaskInfo? = null
+                                 var parent: TaskInfo? = null,
+                                 var parentWeight: Float = 1f,
+                                 var offset: Int = parent?.currentProgress ?: 0) {
         var child: TaskInfo? = null
-        var parentWeight: Float = 1f
         var currentProgress: Int = 0
-        var offset: Int = 0
 
+        /**
+         * Get the further child
+         */
         fun leaf(): TaskInfo {
             var last = this
             while (last.child != null) {
@@ -87,26 +93,27 @@ class DefaultInitialSyncProgressService @Inject constructor() : InitialSyncProgr
             return last
         }
 
-        fun incrementProgress(progress: Int) {
+        /**
+         * Set progress of the parent if any (which will post value), or post the value
+         */
+        fun setProgress(progress: Int) {
             currentProgress = progress
 //            val newProgress = Math.min(currentProgress + progress, totalProgress)
             parent?.let {
                 val parentProgress = (currentProgress * parentWeight).toInt()
-                it.incrementProgress(offset + parentProgress)
+                it.setProgress(offset + parentProgress)
-            }
+            } ?: run {
-            if (parent == null) {
+                Timber.e("--- ${leaf().nameRes}: $currentProgress")
-                Timber.e("--- ${leaf().nameRes}: ${currentProgress}")
                 status.postValue(
                         InitialSyncProgressService.Status(leaf().nameRes, currentProgress)
                 )
             }
         }
     }
-
 }
 
 inline fun <T> reportSubtask(reporter: DefaultInitialSyncProgressService?,
-                             nameRes: Int,
+                             @StringRes nameRes: Int,
                              totalProgress: Int,
                              parentWeight: Float = 1f,
                              block: () -> T): T {
@@ -121,11 +128,11 @@ inline fun <K, V, R> Map<out K, V>.mapWithProgress(reporter: DefaultInitialSyncP
                                                    taskId: Int,
                                                    weight: Float,
                                                    transform: (Map.Entry<K, V>) -> R): List<R> {
-    val total = count()
+    val total = count().toFloat()
     var current = 0
     reporter?.startTask(taskId, 100, weight)
-    return this.map {
+    return map {
-        reporter?.reportProgress((current / total.toFloat() * 100).toInt())
+        reporter?.reportProgress((current / total * 100).toInt())
         current++
         transform.invoke(it)
     }.also {

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/DefaultSession.kt

@@ -40,7 +40,7 @@ import im.vector.matrix.android.api.session.sync.FilterService
 import im.vector.matrix.android.api.session.sync.SyncState
 import im.vector.matrix.android.api.session.user.UserService
 import im.vector.matrix.android.api.util.MatrixCallbackDelegate
-import im.vector.matrix.android.internal.crypto.CryptoManager
+import im.vector.matrix.android.internal.crypto.DefaultCryptoService
 import im.vector.matrix.android.internal.database.LiveEntityObserver
 import im.vector.matrix.android.internal.session.sync.job.SyncThread
 import im.vector.matrix.android.internal.session.sync.job.SyncWorker
@@ -63,7 +63,7 @@ internal class DefaultSession @Inject constructor(override val sessionParams: Se
                                                   private val signOutService: Lazy<SignOutService>,
                                                   private val pushRuleService: Lazy<PushRuleService>,
                                                   private val pushersService: Lazy<PushersService>,
-                                                  private val cryptoService: Lazy<CryptoManager>,
+                                                  private val cryptoService: Lazy<DefaultCryptoService>,
                                                   private val fileService: Lazy<FileService>,
                                                   private val syncThreadProvider: Provider<SyncThread>,
                                                   private val contentUrlResolver: ContentUrlResolver,

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/CryptoSyncHandler.kt

@@ -22,7 +22,7 @@ import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.api.session.events.model.EventType
 import im.vector.matrix.android.api.session.events.model.toModel
 import im.vector.matrix.android.api.session.room.model.message.MessageContent
-import im.vector.matrix.android.internal.crypto.CryptoManager
+import im.vector.matrix.android.internal.crypto.DefaultCryptoService
 import im.vector.matrix.android.internal.crypto.MXEventDecryptionResult
 import im.vector.matrix.android.internal.crypto.algorithms.olm.OlmDecryptionResult
 import im.vector.matrix.android.internal.crypto.verification.DefaultSasVerificationService
@@ -33,7 +33,7 @@ import timber.log.Timber
 import javax.inject.Inject
 
 
-internal class CryptoSyncHandler @Inject constructor(private val cryptoManager: CryptoManager,
+internal class CryptoSyncHandler @Inject constructor(private val cryptoService: DefaultCryptoService,
                                                      private val sasVerificationService: DefaultSasVerificationService) {
 
     fun handleToDevice(toDevice: ToDeviceSyncResponse, initialSyncProgressService: DefaultInitialSyncProgressService? = null) {
@@ -47,13 +47,13 @@ internal class CryptoSyncHandler @Inject constructor(private val cryptoManager:
                 Timber.e("## handleToDeviceEvent() : Warning: Unable to decrypt to-device event : " + event.content)
             } else {
                 sasVerificationService.onToDeviceEvent(event)
-                cryptoManager.onToDeviceEvent(event)
+                cryptoService.onToDeviceEvent(event)
             }
         }
     }
 
     fun onSyncCompleted(syncResponse: SyncResponse) {
-        cryptoManager.onSyncCompleted(syncResponse)
+        cryptoService.onSyncCompleted(syncResponse)
     }
 
 
@@ -68,7 +68,7 @@ internal class CryptoSyncHandler @Inject constructor(private val cryptoManager:
         if (event.getClearType() == EventType.ENCRYPTED) {
             var result: MXEventDecryptionResult? = null
             try {
-                result = cryptoManager.decryptEvent(event, timelineId ?: "")
+                result = cryptoService.decryptEvent(event, timelineId ?: "")
             } catch (exception: MXCryptoError) {
                 event.mCryptoError = (exception as? MXCryptoError.Base)?.errorType //setCryptoError(exception.cryptoError)
             }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/RoomSyncHandler.kt

@@ -23,7 +23,7 @@ import im.vector.matrix.android.api.session.events.model.EventType
 import im.vector.matrix.android.api.session.events.model.toModel
 import im.vector.matrix.android.api.session.room.model.Membership
 import im.vector.matrix.android.api.session.room.model.tag.RoomTagContent
-import im.vector.matrix.android.internal.crypto.CryptoManager
+import im.vector.matrix.android.internal.crypto.DefaultCryptoService
 import im.vector.matrix.android.internal.database.helper.*
 import im.vector.matrix.android.internal.database.model.ChunkEntity
 import im.vector.matrix.android.internal.database.model.EventEntityFields
@@ -50,7 +50,7 @@ internal class RoomSyncHandler @Inject constructor(private val monarchy: Monarch
                                                    private val readReceiptHandler: ReadReceiptHandler,
                                                    private val roomSummaryUpdater: RoomSummaryUpdater,
                                                    private val roomTagHandler: RoomTagHandler,
-                                                   private val cryptoManager: CryptoManager,
+                                                   private val cryptoService: DefaultCryptoService,
                                                    private val tokenStore: SyncTokenStore,
                                                    private val pushRuleService: DefaultPushRuleService,
                                                    private val processForPushTask: ProcessEventForPushTask,
@@ -97,12 +97,12 @@ internal class RoomSyncHandler @Inject constructor(private val monarchy: Monarch
                     handleJoinedRoom(realm, it.key, it.value, isInitialSync)
                 }
             is HandlingStrategy.INVITED ->
-                handlingStrategy.data.mapWithProgress(reporter, R.string.initial_sync_start_importing_account_invited_rooms, 0.4f) {
+                handlingStrategy.data.mapWithProgress(reporter, R.string.initial_sync_start_importing_account_invited_rooms, 0.1f) {
                     handleInvitedRoom(realm, it.key, it.value)
                 }
 
             is HandlingStrategy.LEFT    -> {
-                handlingStrategy.data.mapWithProgress(reporter, R.string.initial_sync_start_importing_account_left_rooms, 0.2f) {
+                handlingStrategy.data.mapWithProgress(reporter, R.string.initial_sync_start_importing_account_left_rooms, 0.3f) {
                     handleLeftRoom(realm, it.key, it.value)
                 }
             }
@@ -125,8 +125,7 @@ internal class RoomSyncHandler @Inject constructor(private val monarchy: Monarch
             handleRoomAccountDataEvents(realm, roomId, roomSync.accountData)
         }
 
-        val roomEntity = RoomEntity.where(realm, roomId).findFirst()
+        val roomEntity = RoomEntity.where(realm, roomId).findFirst() ?: realm.createObject(roomId)
-                         ?: realm.createObject(roomId)
 
         if (roomEntity.membership == Membership.INVITE) {
             roomEntity.chunks.deleteAllFromRealm()
@@ -135,13 +134,12 @@ internal class RoomSyncHandler @Inject constructor(private val monarchy: Monarch
 
         // State event
         if (roomSync.state != null && roomSync.state.events.isNotEmpty()) {
-            val minStateIndex = roomEntity.untimelinedStateEvents.where().min(EventEntityFields.STATE_INDEX)?.toInt()
+            val minStateIndex = roomEntity.untimelinedStateEvents.where().min(EventEntityFields.STATE_INDEX)?.toInt() ?: Int.MIN_VALUE
-                                ?: Int.MIN_VALUE
             val untimelinedStateIndex = minStateIndex + 1
             roomSync.state.events.forEach { event ->
                 roomEntity.addStateEvent(event, filterDuplicates = true, stateIndex = untimelinedStateIndex)
                 // Give info to crypto module
-                cryptoManager.onStateEvent(roomId, event)
+                cryptoService.onStateEvent(roomId, event)
                 UserEntityFactory.createOrNull(event)?.also {
                     realm.insertOrUpdate(it)
                 }
@@ -167,8 +165,7 @@ internal class RoomSyncHandler @Inject constructor(private val monarchy: Monarch
                                   roomSync:
                                   InvitedRoomSync): RoomEntity {
         Timber.v("Handle invited sync for room $roomId")
-        val roomEntity = RoomEntity.where(realm, roomId).findFirst()
+        val roomEntity = RoomEntity.where(realm, roomId).findFirst() ?: realm.createObject(roomId)
-                         ?: realm.createObject(roomId)
         roomEntity.membership = Membership.INVITE
         if (roomSync.inviteState != null && roomSync.inviteState.events.isNotEmpty()) {
             val chunkEntity = handleTimelineEvents(realm, roomEntity, roomSync.inviteState.events)
@@ -181,8 +178,7 @@ internal class RoomSyncHandler @Inject constructor(private val monarchy: Monarch
     private fun handleLeftRoom(realm: Realm,
                                roomId: String,
                                roomSync: RoomSync): RoomEntity {
-        val roomEntity = RoomEntity.where(realm, roomId).findFirst()
+        val roomEntity = RoomEntity.where(realm, roomId).findFirst() ?: realm.createObject(roomId)
-                         ?: realm.createObject(roomId)
 
         roomEntity.membership = Membership.LEAVE
         roomEntity.chunks.deleteAllFromRealm()
@@ -214,7 +210,7 @@ internal class RoomSyncHandler @Inject constructor(private val monarchy: Monarch
             event.eventId?.also { eventIds.add(it) }
             chunkEntity.add(roomEntity.roomId, event, PaginationDirection.FORWARDS, stateIndexOffset)
             // Give info to crypto module
-            cryptoManager.onLiveEvent(roomEntity.roomId, event)
+            cryptoService.onLiveEvent(roomEntity.roomId, event)
             // Try to remove local echo
             event.unsignedData?.transactionId?.also {
                 val sendingEventEntity = roomEntity.sendingTimelineEvents.find(it)

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/SyncResponseHandler.kt

@@ -18,7 +18,7 @@ package im.vector.matrix.android.internal.session.sync
 
 import arrow.core.Try
 import im.vector.matrix.android.R
-import im.vector.matrix.android.internal.crypto.CryptoManager
+import im.vector.matrix.android.internal.crypto.DefaultCryptoService
 import im.vector.matrix.android.internal.session.DefaultInitialSyncProgressService
 import im.vector.matrix.android.internal.session.reportSubtask
 import im.vector.matrix.android.internal.session.sync.model.SyncResponse
@@ -30,7 +30,7 @@ internal class SyncResponseHandler @Inject constructor(private val roomSyncHandl
                                                        private val userAccountDataSyncHandler: UserAccountDataSyncHandler,
                                                        private val groupSyncHandler: GroupSyncHandler,
                                                        private val cryptoSyncHandler: CryptoSyncHandler,
-                                                       private val cryptoManager: CryptoManager,
+                                                       private val cryptoService: DefaultCryptoService,
                                                        private val initialSyncProgressService: DefaultInitialSyncProgressService) {
 
     fun handleResponse(syncResponse: SyncResponse, fromToken: String?, isCatchingUp: Boolean): Try<SyncResponse> {
@@ -40,12 +40,12 @@ internal class SyncResponseHandler @Inject constructor(private val roomSyncHandl
             val reporter = initialSyncProgressService.takeIf { isInitialSync }
 
             measureTimeMillis {
-                if (!cryptoManager.isStarted()) {
+                if (!cryptoService.isStarted()) {
-                    Timber.v("Should start cryptoManager")
+                    Timber.v("Should start cryptoService")
-                    cryptoManager.start(isInitialSync)
+                    cryptoService.start(isInitialSync)
                 }
             }.also {
-                Timber.v("Finish handling start cryptoManager in $it ms")
+                Timber.v("Finish handling start cryptoService in $it ms")
             }
             val measure = measureTimeMillis {
                 // Handle the to device events before the room ones

vector/src/main/java/im/vector/riotx/features/home/HomeActivity.kt

@@ -26,7 +26,6 @@ import androidx.appcompat.widget.Toolbar
 import androidx.core.view.GravityCompat
 import androidx.core.view.isVisible
 import androidx.drawerlayout.widget.DrawerLayout
-import androidx.fragment.app.FragmentManager
 import androidx.lifecycle.Observer
 import androidx.lifecycle.ViewModelProviders
 import com.airbnb.mvrx.viewModel
@@ -36,12 +35,10 @@ import im.vector.riotx.core.di.ScreenComponent
 import im.vector.riotx.core.extensions.hideKeyboard
 import im.vector.riotx.core.extensions.observeEvent
 import im.vector.riotx.core.extensions.replaceFragment
-import im.vector.riotx.core.platform.OnBackPressed
 import im.vector.riotx.core.platform.ToolbarConfigurable
 import im.vector.riotx.core.platform.VectorBaseActivity
 import im.vector.riotx.core.pushers.PushersManager
 import im.vector.riotx.features.disclaimer.showDisclaimerDialog
-import im.vector.riotx.features.navigation.Navigator
 import im.vector.riotx.features.notifications.NotificationDrawerManager
 import im.vector.riotx.features.rageshake.VectorUncaughtExceptionHandler
 import im.vector.riotx.features.workers.signout.SignOutViewModel
@@ -119,22 +116,22 @@ class HomeActivity : VectorBaseActivity(), ToolbarConfigurable {
             intent.removeExtra(EXTRA_CLEAR_EXISTING_NOTIFICATION)
         }
 
-        activeSessionHolder.getSafeActiveSession()?.getLiveStatus()?.observe(this, Observer { sprogress ->
+        activeSessionHolder.getSafeActiveSession()?.getInitialSyncProgressStatus()?.observe(this, Observer { status ->
-            Timber.e("${sprogress?.statusText?.let { getString(it) }} ${sprogress?.percentProgress}")
+            if (status == null) {
-            if (sprogress == null) {
                 waiting_view.isVisible = false
             } else {
+                Timber.e("${getString(status.statusText)} ${status.percentProgress}")
                 waiting_view.setOnClickListener {
                     //block interactions
                 }
                 waiting_view_status_horizontal_progress.apply {
                     isIndeterminate = false
                     max = 100
-                    progress = sprogress.percentProgress
+                    progress = status.percentProgress
                     isVisible = true
                 }
                 waiting_view_status_text.apply {
-                    text = sprogress.statusText?.let { getString(it) }
+                    text = getString(status.statusText)
                     isVisible = true
                 }
                 waiting_view.isVisible = true
@@ -213,8 +210,6 @@ class HomeActivity : VectorBaseActivity(), ToolbarConfigurable {
     }
 
 
-
-
     companion object {
         private const val EXTRA_CLEAR_EXISTING_NOTIFICATION = "EXTRA_CLEAR_EXISTING_NOTIFICATION"
 

vector/src/main/java/im/vector/riotx/features/rageshake/BugReporter.kt

@@ -349,20 +349,20 @@ class BugReporter @Inject constructor(private val activeSessionHolder: ActiveSes
                         } else if (null == response || null == response.body()) {
                             serverError = "Failed with error $responseCode"
                         } else {
-                            var `is`: InputStream? = null
+                            var inputStream: InputStream? = null
 
                             try {
-                                `is` = response.body()!!.byteStream()
+                                inputStream = response.body()!!.byteStream()
 
-                                if (null != `is`) {
+                                if (null != inputStream) {
-                                    var ch = `is`.read()
+                                    var ch = inputStream.read()
                                     val b = StringBuilder()
                                     while (ch != -1) {
                                         b.append(ch.toChar())
-                                        ch = `is`.read()
+                                        ch = inputStream.read()
                                     }
                                     serverError = b.toString()
-                                    `is`.close()
+                                    inputStream.close()
 
                                     // check if the error message
                                     try {
@@ -381,7 +381,7 @@ class BugReporter @Inject constructor(private val activeSessionHolder: ActiveSes
                                 Timber.e(e, "## sendBugReport() : failed to parse error " + e.message)
                             } finally {
                                 try {
-                                    `is`?.close()
+                                    inputStream?.close()
                                 } catch (e: Exception) {
                                     Timber.e(e, "## sendBugReport() : failed to close the error stream " + e.message)
                                 }