fix: repair imports and log detailed backup steps

Author: cyb3rko

app/src/main/kotlin/de/cyb3rko/pincredible/data/PinTable.kt

@@ -16,10 +16,11 @@
 
 package de.cyb3rko.pincredible.data
 
-import android.util.Log
 import de.cyb3rko.backpack.crypto.CryptoManager
 import de.cyb3rko.backpack.data.Serializable
 import de.cyb3rko.backpack.utils.ObjectSerializer
+import de.cyb3rko.backpack.utils.logD
+import de.cyb3rko.backpack.utils.logW
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
 
@@ -75,17 +76,25 @@ internal class PinTable : Serializable() {
 
     @Suppress("UNCHECKED_CAST")
     override suspend fun loadFromBytes(bytes: ByteArray): Serializable? {
+        logD(TAG, "Found ${bytes.size} bytes for $CLASS_NAME($SIZE)")
+        if (bytes.size != SIZE) {
+            // New PINs should have the correct size, but legacy PINs can have one additional byte
+            logW(TAG, "Unexpected $CLASS_NAME($SIZE) size: ${bytes.size}")
+        }
         ByteArrayInputStream(bytes).use {
             val version = it.read()
-            Log.d("PINcredible", "Found PinTable v$version")
+            logD(TAG, "Found $CLASS_NAME v$version")
             if (version > getVersion()) {
-                Log.d("PINcredible", "PinTable version not supported")
+                logD(TAG, "$CLASS_NAME version not supported")
                 return null
             }
+            logD(TAG, "Size of $CLASS_NAME-version: ${Byte.SIZE_BYTES} bytes")
             val buffer = ByteArray(307)
             it.read(buffer)
+            logD(TAG, "Size of $CLASS_NAME-data: ${buffer.size} bytes")
             data = ObjectSerializer.deserialize(buffer) as Array<IntArray>
             it.read(buffer)
+            logD(TAG, "Size of $CLASS_NAME-pattern: ${buffer.size} bytes")
             pattern = ObjectSerializer.deserialize(buffer) as Array<IntArray>
         }
         return this
@@ -94,20 +103,27 @@ internal class PinTable : Serializable() {
     override suspend fun toBytes(): ByteArray {
         val stream = ByteArrayOutputStream()
         stream.use {
-            it.write(byteArrayOf(getVersion()))
+            val version = byteArrayOf(getVersion())
+            logD(TAG, "Size of $CLASS_NAME-version: ${version.size} bytes")
+            it.write(version)
             var byteArray = ObjectSerializer.serialize(data)
-            Log.d("PINcredible", "Size of PinTable-data: ${byteArray.size}")
+            logD(TAG, "Size of $CLASS_NAME-data: ${byteArray.size} bytes")
             it.write(byteArray)
             byteArray = ObjectSerializer.serialize(pattern)
-            Log.d("PINcredible", "Size of PinTable-pattern: ${byteArray.size}")
+            logD(TAG, "Size of $CLASS_NAME-pattern: ${byteArray.size} bytes")
             it.write(byteArray)
         }
-        return stream.toByteArray()
+        val output = stream.toByteArray()
+        logD(TAG, "Size of $CLASS_NAME($SIZE): ${output.size} bytes")
+        return output
     }
 
     override suspend fun getVersion(): Byte = 0
 
     companion object {
+        private const val CLASS_NAME = "PinTable"
+        private const val TAG = "PINcredible-PT"
+
         const val ROW_COUNT = 7
         const val COLUMN_COUNT = 7
         const val SIZE = 615