all: reformat with ktfmt

Signed-off-by: Harsh Shandilya <me@msfjarvis.dev>

4 files changed, 508 insertions, 528 deletions

diff --git a/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpDecryptionResult.kt b/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpDecryptionResult.kt
index ea9c043a..058afa42 100644
--- a/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpDecryptionResult.kt
+++ b/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpDecryptionResult.kt
@@ -12,115 +12,109 @@ import android.os.Parcelable.Creator
 
 public class OpenPgpDecryptionResult() : Parcelable {
 
-    private var result = 0
-    private var sessionKey: ByteArray? = null
-    private var decryptedSessionKey: ByteArray? = null
-
-    private constructor(result: Int) : this() {
-        this.result = result
-        sessionKey = null
-        decryptedSessionKey = null
+  private var result = 0
+  private var sessionKey: ByteArray? = null
+  private var decryptedSessionKey: ByteArray? = null
+
+  private constructor(result: Int) : this() {
+    this.result = result
+    sessionKey = null
+    decryptedSessionKey = null
+  }
+
+  private constructor(result: Int, sessionKey: ByteArray?, decryptedSessionKey: ByteArray?) : this() {
+    this.result = result
+    if (sessionKey == null != (decryptedSessionKey == null)) {
+      throw AssertionError("sessionkey must be null iff decryptedSessionKey is null")
     }
-
-    private constructor(
-        result: Int,
-        sessionKey: ByteArray?,
-        decryptedSessionKey: ByteArray?
-    ) : this() {
-        this.result = result
-        if (sessionKey == null != (decryptedSessionKey == null)) {
-            throw AssertionError("sessionkey must be null iff decryptedSessionKey is null")
-        }
-        this.sessionKey = sessionKey
-        this.decryptedSessionKey = decryptedSessionKey
-    }
-
-    public fun getResult(): Int {
-        return result
-    }
-
-    public fun hasDecryptedSessionKey(): Boolean {
-        return sessionKey != null
-    }
-
-    public fun getSessionKey(): ByteArray? {
-        return if (sessionKey == null) {
-            null
-        } else sessionKey!!.copyOf(sessionKey!!.size)
-    }
-
-    public fun getDecryptedSessionKey(): ByteArray? {
-        return if (sessionKey == null || decryptedSessionKey == null) {
-            null
-        } else decryptedSessionKey!!.copyOf(decryptedSessionKey!!.size)
-    }
-
-    override fun describeContents(): Int {
-        return 0
-    }
-
-    override fun writeToParcel(dest: Parcel, flags: Int) {
-        /**
-         * NOTE: When adding fields in the process of updating this API, make sure to bump
-         * [.PARCELABLE_VERSION].
-         */
-        dest.writeInt(PARCELABLE_VERSION)
-        // Inject a placeholder that will store the parcel size from this point on
-        // (not including the size itself).
-        val sizePosition = dest.dataPosition()
-        dest.writeInt(0)
-        val startPosition = dest.dataPosition()
-        // version 1
-        dest.writeInt(result)
-        // version 2
-        dest.writeByteArray(sessionKey)
-        dest.writeByteArray(decryptedSessionKey)
-        // Go back and write the size
-        val parcelableSize = dest.dataPosition() - startPosition
-        dest.setDataPosition(sizePosition)
-        dest.writeInt(parcelableSize)
-        dest.setDataPosition(startPosition + parcelableSize)
-    }
-
-    override fun toString(): String {
-        return "\nresult: $result"
+    this.sessionKey = sessionKey
+    this.decryptedSessionKey = decryptedSessionKey
+  }
+
+  public fun getResult(): Int {
+    return result
+  }
+
+  public fun hasDecryptedSessionKey(): Boolean {
+    return sessionKey != null
+  }
+
+  public fun getSessionKey(): ByteArray? {
+    return if (sessionKey == null) {
+      null
+    } else sessionKey!!.copyOf(sessionKey!!.size)
+  }
+
+  public fun getDecryptedSessionKey(): ByteArray? {
+    return if (sessionKey == null || decryptedSessionKey == null) {
+      null
+    } else decryptedSessionKey!!.copyOf(decryptedSessionKey!!.size)
+  }
+
+  override fun describeContents(): Int {
+    return 0
+  }
+
+  override fun writeToParcel(dest: Parcel, flags: Int) {
+    /**
+     * NOTE: When adding fields in the process of updating this API, make sure to bump
+     * [.PARCELABLE_VERSION].
+     */
+    dest.writeInt(PARCELABLE_VERSION)
+    // Inject a placeholder that will store the parcel size from this point on
+    // (not including the size itself).
+    val sizePosition = dest.dataPosition()
+    dest.writeInt(0)
+    val startPosition = dest.dataPosition()
+    // version 1
+    dest.writeInt(result)
+    // version 2
+    dest.writeByteArray(sessionKey)
+    dest.writeByteArray(decryptedSessionKey)
+    // Go back and write the size
+    val parcelableSize = dest.dataPosition() - startPosition
+    dest.setDataPosition(sizePosition)
+    dest.writeInt(parcelableSize)
+    dest.setDataPosition(startPosition + parcelableSize)
+  }
+
+  override fun toString(): String {
+    return "\nresult: $result"
+  }
+
+  public companion object CREATOR : Creator<OpenPgpDecryptionResult> {
+
+    /**
+     * Since there might be a case where new versions of the client using the library getting old
+     * versions of the protocol (and thus old versions of this class), we need a versioning system
+     * for the parcels sent between the clients and the providers.
+     */
+    private const val PARCELABLE_VERSION = 2
+
+    // content not encrypted
+    public const val RESULT_NOT_ENCRYPTED: Int = -1
+
+    // insecure!
+    public const val RESULT_INSECURE: Int = 0
+
+    // encrypted
+    public const val RESULT_ENCRYPTED: Int = 1
+
+    override fun createFromParcel(source: Parcel): OpenPgpDecryptionResult? {
+      val version = source.readInt() // parcelableVersion
+      val parcelableSize = source.readInt()
+      val startPosition = source.dataPosition()
+      val result = source.readInt()
+      val sessionKey = if (version > 1) source.createByteArray() else null
+      val decryptedSessionKey = if (version > 1) source.createByteArray() else null
+      val vr = OpenPgpDecryptionResult(result, sessionKey, decryptedSessionKey)
+      // skip over all fields added in future versions of this parcel
+      source.setDataPosition(startPosition + parcelableSize)
+      return vr
     }
 
-    public companion object CREATOR : Creator<OpenPgpDecryptionResult> {
-
-        /**
-         * Since there might be a case where new versions of the client using the library getting
-         * old versions of the protocol (and thus old versions of this class), we need a versioning
-         * system for the parcels sent between the clients and the providers.
-         */
-        private const val PARCELABLE_VERSION  = 2
-
-        // content not encrypted
-        public const val RESULT_NOT_ENCRYPTED: Int  = -1
-
-        // insecure!
-        public const val RESULT_INSECURE: Int  = 0
-
-        // encrypted
-        public const val RESULT_ENCRYPTED: Int  = 1
-
-        override fun createFromParcel(source: Parcel): OpenPgpDecryptionResult? {
-            val version = source.readInt() // parcelableVersion
-            val parcelableSize = source.readInt()
-            val startPosition = source.dataPosition()
-            val result = source.readInt()
-            val sessionKey = if (version > 1) source.createByteArray() else null
-            val decryptedSessionKey =
-                if (version > 1) source.createByteArray() else null
-            val vr =
-                OpenPgpDecryptionResult(result, sessionKey, decryptedSessionKey)
-            // skip over all fields added in future versions of this parcel
-            source.setDataPosition(startPosition + parcelableSize)
-            return vr
-        }
-
-        override fun newArray(size: Int): Array<OpenPgpDecryptionResult?> {
-            return arrayOfNulls(size)
-        }
+    override fun newArray(size: Int): Array<OpenPgpDecryptionResult?> {
+      return arrayOfNulls(size)
     }
+  }
 }
diff --git a/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpError.kt b/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpError.kt
index 30d64b16..fb1c9602 100644
--- a/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpError.kt
+++ b/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpError.kt
@@ -12,80 +12,80 @@ import android.os.Parcelable.Creator
 
 public class OpenPgpError() : Parcelable {
 
-    public var errorId: Int = 0
-    public var message: String? = null
+  public var errorId: Int = 0
+  public var message: String? = null
 
-    private constructor(parcel: Parcel) : this() {
-        errorId = parcel.readInt()
-        message = parcel.readString()
-    }
+  private constructor(parcel: Parcel) : this() {
+    errorId = parcel.readInt()
+    message = parcel.readString()
+  }
 
-    internal constructor(errorId: Int, message: String?) : this() {
-        this.errorId = errorId
-        this.message = message
-    }
+  internal constructor(errorId: Int, message: String?) : this() {
+    this.errorId = errorId
+    this.message = message
+  }
 
-    internal constructor(b: OpenPgpError) : this() {
-        errorId = b.errorId
-        message = b.message
-    }
+  internal constructor(b: OpenPgpError) : this() {
+    errorId = b.errorId
+    message = b.message
+  }
 
-    override fun describeContents(): Int {
-        return 0
-    }
+  override fun describeContents(): Int {
+    return 0
+  }
 
-    override fun writeToParcel(dest: Parcel, flags: Int) {
-        /**
-         * NOTE: When adding fields in the process of updating this API, make sure to bump
-         * [PARCELABLE_VERSION].
-         */
-        dest.writeInt(PARCELABLE_VERSION)
-        // Inject a placeholder that will store the parcel size from this point on
-        // (not including the size itself).
-        val sizePosition = dest.dataPosition()
-        dest.writeInt(0)
-        val startPosition = dest.dataPosition()
-        // version 1
-        dest.writeInt(errorId)
-        dest.writeString(message)
-        // Go back and write the size
-        val parcelableSize = dest.dataPosition() - startPosition
-        dest.setDataPosition(sizePosition)
-        dest.writeInt(parcelableSize)
-        dest.setDataPosition(startPosition + parcelableSize)
-    }
+  override fun writeToParcel(dest: Parcel, flags: Int) {
+    /**
+     * NOTE: When adding fields in the process of updating this API, make sure to bump
+     * [PARCELABLE_VERSION].
+     */
+    dest.writeInt(PARCELABLE_VERSION)
+    // Inject a placeholder that will store the parcel size from this point on
+    // (not including the size itself).
+    val sizePosition = dest.dataPosition()
+    dest.writeInt(0)
+    val startPosition = dest.dataPosition()
+    // version 1
+    dest.writeInt(errorId)
+    dest.writeString(message)
+    // Go back and write the size
+    val parcelableSize = dest.dataPosition() - startPosition
+    dest.setDataPosition(sizePosition)
+    dest.writeInt(parcelableSize)
+    dest.setDataPosition(startPosition + parcelableSize)
+  }
 
-    public companion object CREATOR : Creator<OpenPgpError> {
+  public companion object CREATOR : Creator<OpenPgpError> {
 
-        /**
-         * Since there might be a case where new versions of the client using the library getting
-         * old versions of the protocol (and thus old versions of this class), we need a versioning
-         * system for the parcels sent between the clients and the providers.
-         */
-        private const val PARCELABLE_VERSION = 1
+    /**
+     * Since there might be a case where new versions of the client using the library getting old
+     * versions of the protocol (and thus old versions of this class), we need a versioning system
+     * for the parcels sent between the clients and the providers.
+     */
+    private const val PARCELABLE_VERSION = 1
 
-        // possible values for errorId
-        public const val CLIENT_SIDE_ERROR: Int = -1
-        public const val GENERIC_ERROR: Int = 0
-        public const val INCOMPATIBLE_API_VERSIONS: Int = 1
-        public const val NO_OR_WRONG_PASSPHRASE: Int = 2
-        public const val NO_USER_IDS: Int = 3
-        public const val OPPORTUNISTIC_MISSING_KEYS: Int = 4
+    // possible values for errorId
+    public const val CLIENT_SIDE_ERROR: Int = -1
+    public const val GENERIC_ERROR: Int = 0
+    public const val INCOMPATIBLE_API_VERSIONS: Int = 1
+    public const val NO_OR_WRONG_PASSPHRASE: Int = 2
+    public const val NO_USER_IDS: Int = 3
+    public const val OPPORTUNISTIC_MISSING_KEYS: Int = 4
 
-        override fun createFromParcel(source: Parcel): OpenPgpError? {
-            source.readInt() // parcelableVersion
-            val parcelableSize = source.readInt()
-            val startPosition = source.dataPosition()
-            val error = OpenPgpError()
-            error.errorId = source.readInt()
-            error.message = source.readString()
-            // skip over all fields added in future versions of this parcel
-            source.setDataPosition(startPosition + parcelableSize)
-            return error
-        }
+    override fun createFromParcel(source: Parcel): OpenPgpError? {
+      source.readInt() // parcelableVersion
+      val parcelableSize = source.readInt()
+      val startPosition = source.dataPosition()
+      val error = OpenPgpError()
+      error.errorId = source.readInt()
+      error.message = source.readString()
+      // skip over all fields added in future versions of this parcel
+      source.setDataPosition(startPosition + parcelableSize)
+      return error
+    }
 
-        override fun newArray(size: Int): Array<OpenPgpError?> {
-            return arrayOfNulls(size)
-        }
+    override fun newArray(size: Int): Array<OpenPgpError?> {
+      return arrayOfNulls(size)
     }
+  }
 }
diff --git a/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpMetadata.kt b/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpMetadata.kt
index 81b200e1..b590456a 100644
--- a/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpMetadata.kt
+++ b/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpMetadata.kt
@@ -12,111 +12,106 @@ import android.os.Parcelable.Creator
 
 public class OpenPgpMetadata() : Parcelable {
 
-    public var filename: String? = null
-    public var mimeType: String? = null
-    public var charset: String? = null
-    public var modificationTime: Long = 0
-    public var originalSize: Long = 0
+  public var filename: String? = null
+  public var mimeType: String? = null
+  public var charset: String? = null
+  public var modificationTime: Long = 0
+  public var originalSize: Long = 0
 
-    private constructor(
-        filename: String?,
-        mimeType: String?,
-        modificationTime: Long,
-        originalSize: Long,
-        charset: String?
-    ) : this() {
-        this.filename = filename
-        this.mimeType = mimeType
-        this.modificationTime = modificationTime
-        this.originalSize = originalSize
-        this.charset = charset
-    }
+  private constructor(
+    filename: String?,
+    mimeType: String?,
+    modificationTime: Long,
+    originalSize: Long,
+    charset: String?
+  ) : this() {
+    this.filename = filename
+    this.mimeType = mimeType
+    this.modificationTime = modificationTime
+    this.originalSize = originalSize
+    this.charset = charset
+  }
 
-    private constructor(
-        filename: String?,
-        mimeType: String?,
-        modificationTime: Long,
-        originalSize: Long
-    ) : this() {
-        this.filename = filename
-        this.mimeType = mimeType
-        this.modificationTime = modificationTime
-        this.originalSize = originalSize
-    }
+  private constructor(filename: String?, mimeType: String?, modificationTime: Long, originalSize: Long) : this() {
+    this.filename = filename
+    this.mimeType = mimeType
+    this.modificationTime = modificationTime
+    this.originalSize = originalSize
+  }
 
-    private constructor(b: OpenPgpMetadata) : this() {
-        filename = b.filename
-        mimeType = b.mimeType
-        modificationTime = b.modificationTime
-        originalSize = b.originalSize
-    }
+  private constructor(b: OpenPgpMetadata) : this() {
+    filename = b.filename
+    mimeType = b.mimeType
+    modificationTime = b.modificationTime
+    originalSize = b.originalSize
+  }
 
-    override fun describeContents(): Int {
-        return 0
-    }
+  override fun describeContents(): Int {
+    return 0
+  }
 
-    override fun writeToParcel(dest: Parcel, flags: Int) {
-        /**
-         * NOTE: When adding fields in the process of updating this API, make sure to bump
-         * [PARCELABLE_VERSION].
-         */
-        dest.writeInt(PARCELABLE_VERSION)
-        // Inject a placeholder that will store the parcel size from this point on
-        // (not including the size itself).
-        val sizePosition = dest.dataPosition()
-        dest.writeInt(0)
-        val startPosition = dest.dataPosition()
-        // version 1
-        dest.writeString(filename)
-        dest.writeString(mimeType)
-        dest.writeLong(modificationTime)
-        dest.writeLong(originalSize)
-        // version 2
-        dest.writeString(charset)
-        // Go back and write the size
-        val parcelableSize = dest.dataPosition() - startPosition
-        dest.setDataPosition(sizePosition)
-        dest.writeInt(parcelableSize)
-        dest.setDataPosition(startPosition + parcelableSize)
-    }
-
-    public companion object CREATOR : Creator<OpenPgpMetadata> {
+  override fun writeToParcel(dest: Parcel, flags: Int) {
+    /**
+     * NOTE: When adding fields in the process of updating this API, make sure to bump
+     * [PARCELABLE_VERSION].
+     */
+    dest.writeInt(PARCELABLE_VERSION)
+    // Inject a placeholder that will store the parcel size from this point on
+    // (not including the size itself).
+    val sizePosition = dest.dataPosition()
+    dest.writeInt(0)
+    val startPosition = dest.dataPosition()
+    // version 1
+    dest.writeString(filename)
+    dest.writeString(mimeType)
+    dest.writeLong(modificationTime)
+    dest.writeLong(originalSize)
+    // version 2
+    dest.writeString(charset)
+    // Go back and write the size
+    val parcelableSize = dest.dataPosition() - startPosition
+    dest.setDataPosition(sizePosition)
+    dest.writeInt(parcelableSize)
+    dest.setDataPosition(startPosition + parcelableSize)
+  }
 
-        /**
-         * Since there might be a case where new versions of the client using the library getting
-         * old versions of the protocol (and thus old versions of this class), we need a versioning
-         * system for the parcels sent between the clients and the providers.
-         */
-        private const val PARCELABLE_VERSION = 2
+  public companion object CREATOR : Creator<OpenPgpMetadata> {
 
-        override fun createFromParcel(source: Parcel): OpenPgpMetadata? {
-            val version = source.readInt() // parcelableVersion
-            val parcelableSize = source.readInt()
-            val startPosition = source.dataPosition()
-            val vr = OpenPgpMetadata()
-            vr.filename = source.readString()
-            vr.mimeType = source.readString()
-            vr.modificationTime = source.readLong()
-            vr.originalSize = source.readLong()
-            if (version >= 2) {
-                vr.charset = source.readString()
-            }
-            // skip over all fields added in future versions of this parcel
-            source.setDataPosition(startPosition + parcelableSize)
-            return vr
-        }
+    /**
+     * Since there might be a case where new versions of the client using the library getting old
+     * versions of the protocol (and thus old versions of this class), we need a versioning system
+     * for the parcels sent between the clients and the providers.
+     */
+    private const val PARCELABLE_VERSION = 2
 
-        override fun newArray(size: Int): Array<OpenPgpMetadata?> {
-            return arrayOfNulls(size)
-        }
+    override fun createFromParcel(source: Parcel): OpenPgpMetadata? {
+      val version = source.readInt() // parcelableVersion
+      val parcelableSize = source.readInt()
+      val startPosition = source.dataPosition()
+      val vr = OpenPgpMetadata()
+      vr.filename = source.readString()
+      vr.mimeType = source.readString()
+      vr.modificationTime = source.readLong()
+      vr.originalSize = source.readLong()
+      if (version >= 2) {
+        vr.charset = source.readString()
+      }
+      // skip over all fields added in future versions of this parcel
+      source.setDataPosition(startPosition + parcelableSize)
+      return vr
     }
 
-    override fun toString(): String {
-        var out = "\nfilename: $filename"
-        out += "\nmimeType: $mimeType"
-        out += "\nmodificationTime: $modificationTime"
-        out += "\noriginalSize: $originalSize"
-        out += "\ncharset: $charset"
-        return out
+    override fun newArray(size: Int): Array<OpenPgpMetadata?> {
+      return arrayOfNulls(size)
     }
+  }
+
+  override fun toString(): String {
+    var out = "\nfilename: $filename"
+    out += "\nmimeType: $mimeType"
+    out += "\nmodificationTime: $modificationTime"
+    out += "\noriginalSize: $originalSize"
+    out += "\ncharset: $charset"
+    return out
+  }
 }
diff --git a/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpSignatureResult.kt b/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpSignatureResult.kt
index 78a2d741..3b7e6d1b 100644
--- a/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpSignatureResult.kt
+++ b/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpSignatureResult.kt
@@ -14,281 +14,272 @@ import me.msfjarvis.openpgpktx.util.OpenPgpUtils
 
 public class OpenPgpSignatureResult : Parcelable {
 
-    private val result: Int
-    private val keyId: Long
-    private val primaryUserId: String?
-    private val userIds: ArrayList<String>?
-    private val confirmedUserIds: ArrayList<String>?
-    private val senderStatusResult: SenderStatusResult?
-    private val signatureTimestamp: Date?
-    private val autocryptPeerentityResult: AutocryptPeerResult?
-
-    private constructor(
-        signatureStatus: Int,
-        signatureUserId: String?,
-        keyId: Long,
-        userIds: ArrayList<String>?,
-        confirmedUserIds: ArrayList<String>?,
-        senderStatusResult: SenderStatusResult?,
-        signatureOnly: Boolean?,
-        signatureTimestamp: Date?,
-        autocryptPeerentityResult: AutocryptPeerResult?
-    ) {
-        result = signatureStatus
-        primaryUserId = signatureUserId
-        this.keyId = keyId
-        this.userIds = userIds
-        this.confirmedUserIds = confirmedUserIds
-        this.senderStatusResult = senderStatusResult
-        this.signatureTimestamp = signatureTimestamp
-        this.autocryptPeerentityResult = autocryptPeerentityResult
+  private val result: Int
+  private val keyId: Long
+  private val primaryUserId: String?
+  private val userIds: ArrayList<String>?
+  private val confirmedUserIds: ArrayList<String>?
+  private val senderStatusResult: SenderStatusResult?
+  private val signatureTimestamp: Date?
+  private val autocryptPeerentityResult: AutocryptPeerResult?
+
+  private constructor(
+    signatureStatus: Int,
+    signatureUserId: String?,
+    keyId: Long,
+    userIds: ArrayList<String>?,
+    confirmedUserIds: ArrayList<String>?,
+    senderStatusResult: SenderStatusResult?,
+    signatureOnly: Boolean?,
+    signatureTimestamp: Date?,
+    autocryptPeerentityResult: AutocryptPeerResult?
+  ) {
+    result = signatureStatus
+    primaryUserId = signatureUserId
+    this.keyId = keyId
+    this.userIds = userIds
+    this.confirmedUserIds = confirmedUserIds
+    this.senderStatusResult = senderStatusResult
+    this.signatureTimestamp = signatureTimestamp
+    this.autocryptPeerentityResult = autocryptPeerentityResult
+  }
+
+  private constructor(source: Parcel, version: Int) {
+    result = source.readInt()
+    // we dropped support for signatureOnly, but need to skip the value for compatibility
+    source.readByte()
+    primaryUserId = source.readString()
+    keyId = source.readLong()
+    userIds =
+      if (version > 1) {
+        source.createStringArrayList()
+      } else {
+        null
+      }
+    // backward compatibility for this exact version
+    if (version > 2) {
+      senderStatusResult = readEnumWithNullAndFallback(source, SenderStatusResult.values(), SenderStatusResult.UNKNOWN)
+      confirmedUserIds = source.createStringArrayList()
+    } else {
+      senderStatusResult = SenderStatusResult.UNKNOWN
+      confirmedUserIds = null
     }
-
-    private constructor(source: Parcel, version: Int) {
-        result = source.readInt()
-        // we dropped support for signatureOnly, but need to skip the value for compatibility
-        source.readByte()
-        primaryUserId = source.readString()
-        keyId = source.readLong()
-        userIds = if (version > 1) {
-            source.createStringArrayList()
-        } else {
-            null
-        }
-        // backward compatibility for this exact version
-        if (version > 2) {
-            senderStatusResult = readEnumWithNullAndFallback(
-                source,
-                SenderStatusResult.values(),
-                SenderStatusResult.UNKNOWN
-            )
-            confirmedUserIds = source.createStringArrayList()
-        } else {
-            senderStatusResult = SenderStatusResult.UNKNOWN
-            confirmedUserIds = null
-        }
-        signatureTimestamp = if (version > 3) {
-            if (source.readInt() > 0) Date(source.readLong()) else null
-        } else {
-            null
-        }
-        autocryptPeerentityResult = if (version > 4) {
-            readEnumWithNullAndFallback(
-                source,
-                AutocryptPeerResult.values(),
-                null
-            )
-        } else {
-            null
-        }
-    }
-
-    public fun getUserIds(): List<String> {
-        return (userIds ?: arrayListOf()).toList()
+    signatureTimestamp =
+      if (version > 3) {
+        if (source.readInt() > 0) Date(source.readLong()) else null
+      } else {
+        null
+      }
+    autocryptPeerentityResult =
+      if (version > 4) {
+        readEnumWithNullAndFallback(source, AutocryptPeerResult.values(), null)
+      } else {
+        null
+      }
+  }
+
+  public fun getUserIds(): List<String> {
+    return (userIds ?: arrayListOf()).toList()
+  }
+
+  public fun getConfirmedUserIds(): List<String> {
+    return (confirmedUserIds ?: arrayListOf()).toList()
+  }
+
+  override fun describeContents(): Int {
+    return 0
+  }
+
+  override fun writeToParcel(dest: Parcel, flags: Int) {
+    /**
+     * NOTE: When adding fields in the process of updating this API, make sure to bump
+     * [.PARCELABLE_VERSION].
+     */
+    dest.writeInt(PARCELABLE_VERSION)
+    // Inject a placeholder that will store the parcel size from this point on
+    // (not including the size itself).
+    val sizePosition = dest.dataPosition()
+    dest.writeInt(0)
+    val startPosition = dest.dataPosition()
+    // version 1
+    dest.writeInt(result)
+    // signatureOnly is deprecated since version 3. we pass a dummy value for compatibility
+    dest.writeByte(0.toByte())
+    dest.writeString(primaryUserId)
+    dest.writeLong(keyId)
+    // version 2
+    dest.writeStringList(userIds)
+    // version 3
+    writeEnumWithNull(dest, senderStatusResult)
+    dest.writeStringList(confirmedUserIds)
+    // version 4
+    if (signatureTimestamp != null) {
+      dest.writeInt(1)
+      dest.writeLong(signatureTimestamp.time)
+    } else {
+      dest.writeInt(0)
     }
-
-    public fun getConfirmedUserIds(): List<String> {
-        return (confirmedUserIds ?: arrayListOf()).toList()
-    }
-
-    override fun describeContents(): Int {
-        return 0
+    // version 5
+    writeEnumWithNull(dest, autocryptPeerentityResult)
+    // Go back and write the size
+    val parcelableSize = dest.dataPosition() - startPosition
+    dest.setDataPosition(sizePosition)
+    dest.writeInt(parcelableSize)
+    dest.setDataPosition(startPosition + parcelableSize)
+  }
+
+  override fun toString(): String {
+    var out = "\nresult: $result"
+    out += "\nprimaryUserId: $primaryUserId"
+    out += "\nuserIds: $userIds"
+    out += "\nkeyId: " + OpenPgpUtils.convertKeyIdToHex(keyId)
+    return out
+  }
+
+  @Deprecated("")
+  public fun withSignatureOnlyFlag(signatureOnly: Boolean): OpenPgpSignatureResult {
+    return OpenPgpSignatureResult(
+      result,
+      primaryUserId,
+      keyId,
+      userIds,
+      confirmedUserIds,
+      senderStatusResult,
+      signatureOnly,
+      signatureTimestamp,
+      autocryptPeerentityResult
+    )
+  }
+
+  public fun withAutocryptPeerResult(autocryptPeerentityResult: AutocryptPeerResult?): OpenPgpSignatureResult {
+    return OpenPgpSignatureResult(
+      result,
+      primaryUserId,
+      keyId,
+      userIds,
+      confirmedUserIds,
+      senderStatusResult,
+      null,
+      signatureTimestamp,
+      autocryptPeerentityResult
+    )
+  }
+
+  public enum class SenderStatusResult {
+    UNKNOWN,
+    USER_ID_CONFIRMED,
+    USER_ID_UNCONFIRMED,
+    USER_ID_MISSING
+  }
+
+  public enum class AutocryptPeerResult {
+    OK,
+    NEW,
+    MISMATCH
+  }
+
+  public companion object CREATOR : Creator<OpenPgpSignatureResult> {
+
+    /**
+     * Since there might be a case where new versions of the client using the library getting old
+     * versions of the protocol (and thus old versions of this class), we need a versioning system
+     * for the parcels sent between the clients and the providers.
+     */
+    private const val PARCELABLE_VERSION = 5
+
+    // content not signed
+    public const val RESULT_NO_SIGNATURE: Int = -1
+
+    // invalid signature!
+    public const val RESULT_INVALID_SIGNATURE: Int = 0
+
+    // successfully verified signature, with confirmed key
+    public const val RESULT_VALID_KEY_CONFIRMED: Int = 1
+
+    // no key was found for this signature verification
+    public const val RESULT_KEY_MISSING: Int = 2
+
+    // successfully verified signature, but with unconfirmed key
+    public const val RESULT_VALID_KEY_UNCONFIRMED: Int = 3
+
+    // key has been revoked -> invalid signature!
+    public const val RESULT_INVALID_KEY_REVOKED: Int = 4
+
+    // key is expired -> invalid signature!
+    public const val RESULT_INVALID_KEY_EXPIRED: Int = 5
+
+    // insecure cryptographic algorithms/protocol -> invalid signature!
+    public const val RESULT_INVALID_KEY_INSECURE: Int = 6
+
+    override fun createFromParcel(source: Parcel): OpenPgpSignatureResult? {
+      val version = source.readInt() // parcelableVersion
+      val parcelableSize = source.readInt()
+      val startPosition = source.dataPosition()
+      val vr = OpenPgpSignatureResult(source, version)
+      // skip over all fields added in future versions of this parcel
+      source.setDataPosition(startPosition + parcelableSize)
+      return vr
     }
 
-    override fun writeToParcel(dest: Parcel, flags: Int) {
-        /**
-         * NOTE: When adding fields in the process of updating this API, make sure to bump
-         * [.PARCELABLE_VERSION].
-         */
-        dest.writeInt(PARCELABLE_VERSION)
-        // Inject a placeholder that will store the parcel size from this point on
-        // (not including the size itself).
-        val sizePosition = dest.dataPosition()
-        dest.writeInt(0)
-        val startPosition = dest.dataPosition()
-        // version 1
-        dest.writeInt(result)
-        // signatureOnly is deprecated since version 3. we pass a dummy value for compatibility
-        dest.writeByte(0.toByte())
-        dest.writeString(primaryUserId)
-        dest.writeLong(keyId)
-        // version 2
-        dest.writeStringList(userIds)
-        // version 3
-        writeEnumWithNull(dest, senderStatusResult)
-        dest.writeStringList(confirmedUserIds)
-        // version 4
-        if (signatureTimestamp != null) {
-            dest.writeInt(1)
-            dest.writeLong(signatureTimestamp.time)
-        } else {
-            dest.writeInt(0)
-        }
-        // version 5
-        writeEnumWithNull(dest, autocryptPeerentityResult)
-        // Go back and write the size
-        val parcelableSize = dest.dataPosition() - startPosition
-        dest.setDataPosition(sizePosition)
-        dest.writeInt(parcelableSize)
-        dest.setDataPosition(startPosition + parcelableSize)
+    override fun newArray(size: Int): Array<OpenPgpSignatureResult?> {
+      return arrayOfNulls(size)
     }
 
-    override fun toString(): String {
-        var out = "\nresult: $result"
-        out += "\nprimaryUserId: $primaryUserId"
-        out += "\nuserIds: $userIds"
-        out += "\nkeyId: " + OpenPgpUtils.convertKeyIdToHex(keyId)
-        return out
+    public fun createWithValidSignature(
+      signatureStatus: Int,
+      primaryUserId: String?,
+      keyId: Long,
+      userIds: ArrayList<String>?,
+      confirmedUserIds: ArrayList<String>?,
+      senderStatusResult: SenderStatusResult?,
+      signatureTimestamp: Date?
+    ): OpenPgpSignatureResult {
+      require(
+        !(signatureStatus == RESULT_NO_SIGNATURE ||
+          signatureStatus == RESULT_KEY_MISSING ||
+          signatureStatus == RESULT_INVALID_SIGNATURE)
+      ) { "can only use this method for valid types of signatures" }
+      return OpenPgpSignatureResult(
+        signatureStatus,
+        primaryUserId,
+        keyId,
+        userIds,
+        confirmedUserIds,
+        senderStatusResult,
+        null,
+        signatureTimestamp,
+        null
+      )
     }
 
-    @Deprecated("")
-    public fun withSignatureOnlyFlag(signatureOnly: Boolean): OpenPgpSignatureResult {
-        return OpenPgpSignatureResult(
-            result, primaryUserId, keyId, userIds, confirmedUserIds,
-            senderStatusResult, signatureOnly, signatureTimestamp, autocryptPeerentityResult
-        )
+    public fun createWithNoSignature(): OpenPgpSignatureResult {
+      return OpenPgpSignatureResult(RESULT_NO_SIGNATURE, null, 0L, null, null, null, null, null, null)
     }
 
-    public fun withAutocryptPeerResult(autocryptPeerentityResult: AutocryptPeerResult?): OpenPgpSignatureResult {
-        return OpenPgpSignatureResult(
-            result, primaryUserId, keyId, userIds, confirmedUserIds,
-            senderStatusResult, null, signatureTimestamp, autocryptPeerentityResult
-        )
+    public fun createWithKeyMissing(keyId: Long, signatureTimestamp: Date?): OpenPgpSignatureResult {
+      return OpenPgpSignatureResult(RESULT_KEY_MISSING, null, keyId, null, null, null, null, signatureTimestamp, null)
     }
 
-    public enum class SenderStatusResult {
-        UNKNOWN, USER_ID_CONFIRMED, USER_ID_UNCONFIRMED, USER_ID_MISSING;
+    public fun createWithInvalidSignature(): OpenPgpSignatureResult {
+      return OpenPgpSignatureResult(RESULT_INVALID_SIGNATURE, null, 0L, null, null, null, null, null, null)
     }
 
-    public enum class AutocryptPeerResult {
-        OK, NEW, MISMATCH;
+    private fun <T : Enum<T>?> readEnumWithNullAndFallback(source: Parcel, enumValues: Array<T>, fallback: T?): T? {
+      val valueOrdinal = source.readInt()
+      if (valueOrdinal == -1) {
+        return null
+      }
+      return if (valueOrdinal >= enumValues.size) {
+        fallback
+      } else enumValues[valueOrdinal]
     }
 
-    public companion object CREATOR : Creator<OpenPgpSignatureResult> {
-
-        /**
-         * Since there might be a case where new versions of the client using the library getting
-         * old versions of the protocol (and thus old versions of this class), we need a versioning
-         * system for the parcels sent between the clients and the providers.
-         */
-        private const val PARCELABLE_VERSION = 5
-
-        // content not signed
-        public const val RESULT_NO_SIGNATURE: Int = -1
-
-        // invalid signature!
-        public const val RESULT_INVALID_SIGNATURE: Int = 0
-
-        // successfully verified signature, with confirmed key
-        public const val RESULT_VALID_KEY_CONFIRMED: Int = 1
-
-        // no key was found for this signature verification
-        public const val RESULT_KEY_MISSING: Int = 2
-
-        // successfully verified signature, but with unconfirmed key
-        public const val RESULT_VALID_KEY_UNCONFIRMED: Int = 3
-
-        // key has been revoked -> invalid signature!
-        public const val RESULT_INVALID_KEY_REVOKED: Int = 4
-
-        // key is expired -> invalid signature!
-        public const val RESULT_INVALID_KEY_EXPIRED: Int = 5
-
-        // insecure cryptographic algorithms/protocol -> invalid signature!
-        public const val RESULT_INVALID_KEY_INSECURE: Int = 6
-
-        override fun createFromParcel(source: Parcel): OpenPgpSignatureResult? {
-            val version = source.readInt() // parcelableVersion
-            val parcelableSize = source.readInt()
-            val startPosition = source.dataPosition()
-            val vr = OpenPgpSignatureResult(source, version)
-            // skip over all fields added in future versions of this parcel
-            source.setDataPosition(startPosition + parcelableSize)
-            return vr
-        }
-
-        override fun newArray(size: Int): Array<OpenPgpSignatureResult?> {
-            return arrayOfNulls(size)
-        }
-
-        public fun createWithValidSignature(
-            signatureStatus: Int,
-            primaryUserId: String?,
-            keyId: Long,
-            userIds: ArrayList<String>?,
-            confirmedUserIds: ArrayList<String>?,
-            senderStatusResult: SenderStatusResult?,
-            signatureTimestamp: Date?
-        ): OpenPgpSignatureResult {
-            require(!(signatureStatus == RESULT_NO_SIGNATURE || signatureStatus == RESULT_KEY_MISSING || signatureStatus == RESULT_INVALID_SIGNATURE)) { "can only use this method for valid types of signatures" }
-            return OpenPgpSignatureResult(
-                signatureStatus, primaryUserId, keyId, userIds, confirmedUserIds,
-                senderStatusResult, null, signatureTimestamp, null
-            )
-        }
-
-        public fun createWithNoSignature(): OpenPgpSignatureResult {
-            return OpenPgpSignatureResult(
-                RESULT_NO_SIGNATURE,
-                null,
-                0L,
-                null,
-                null,
-                null,
-                null,
-                null,
-                null
-            )
-        }
-
-        public fun createWithKeyMissing(keyId: Long, signatureTimestamp: Date?): OpenPgpSignatureResult {
-            return OpenPgpSignatureResult(
-                RESULT_KEY_MISSING,
-                null,
-                keyId,
-                null,
-                null,
-                null,
-                null,
-                signatureTimestamp,
-                null
-            )
-        }
-
-        public fun createWithInvalidSignature(): OpenPgpSignatureResult {
-            return OpenPgpSignatureResult(
-                RESULT_INVALID_SIGNATURE,
-                null,
-                0L,
-                null,
-                null,
-                null,
-                null,
-                null,
-                null
-            )
-        }
-
-        private fun <T : Enum<T>?> readEnumWithNullAndFallback(
-            source: Parcel,
-            enumValues: Array<T>,
-            fallback: T?
-        ): T? {
-            val valueOrdinal = source.readInt()
-            if (valueOrdinal == -1) {
-                return null
-            }
-            return if (valueOrdinal >= enumValues.size) {
-                fallback
-            } else enumValues[valueOrdinal]
-        }
-
-        private fun writeEnumWithNull(dest: Parcel, enumValue: Enum<*>?) {
-            if (enumValue == null) {
-                dest.writeInt(-1)
-                return
-            }
-            dest.writeInt(enumValue.ordinal)
-        }
+    private fun writeEnumWithNull(dest: Parcel, enumValue: Enum<*>?) {
+      if (enumValue == null) {
+        dest.writeInt(-1)
+        return
+      }
+      dest.writeInt(enumValue.ordinal)
     }
+  }
 }