mirror of
https://github.com/permissionlesstech/bitchat-android.git
synced 2026-07-25 20:05:21 +00:00
init
This commit is contained in:
callebtc
@@ -0,0 +1,407 @@
|
||||
package com.bitchat.android.model
|
||||
|
||||
import android.os.Parcelable
|
||||
import kotlinx.parcelize.Parcelize
|
||||
import java.nio.ByteBuffer
|
||||
import java.nio.ByteOrder
|
||||
import java.util.*
|
||||
|
||||
/**
|
||||
* Delivery status for messages - exact same as iOS version
|
||||
*/
|
||||
sealed class DeliveryStatus : Parcelable {
|
||||
@Parcelize
|
||||
object Sending : DeliveryStatus()
|
||||
|
||||
@Parcelize
|
||||
object Sent : DeliveryStatus()
|
||||
|
||||
@Parcelize
|
||||
data class Delivered(val to: String, val at: Date) : DeliveryStatus()
|
||||
|
||||
@Parcelize
|
||||
data class Read(val by: String, val at: Date) : DeliveryStatus()
|
||||
|
||||
@Parcelize
|
||||
data class Failed(val reason: String) : DeliveryStatus()
|
||||
|
||||
@Parcelize
|
||||
data class PartiallyDelivered(val reached: Int, val total: Int) : DeliveryStatus()
|
||||
|
||||
fun getDisplayText(): String {
|
||||
return when (this) {
|
||||
is Sending -> "Sending..."
|
||||
is Sent -> "Sent"
|
||||
is Delivered -> "Delivered to ${this.to}"
|
||||
is Read -> "Read by ${this.by}"
|
||||
is Failed -> "Failed: ${this.reason}"
|
||||
is PartiallyDelivered -> "Delivered to ${this.reached}/${this.total}"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* BitchatMessage - 100% compatible with iOS version
|
||||
*/
|
||||
@Parcelize
|
||||
data class BitchatMessage(
|
||||
val id: String = UUID.randomUUID().toString(),
|
||||
val sender: String,
|
||||
val content: String,
|
||||
val timestamp: Date,
|
||||
val isRelay: Boolean = false,
|
||||
val originalSender: String? = null,
|
||||
val isPrivate: Boolean = false,
|
||||
val recipientNickname: String? = null,
|
||||
val senderPeerID: String? = null,
|
||||
val mentions: List<String>? = null,
|
||||
val channel: String? = null,
|
||||
val encryptedContent: ByteArray? = null,
|
||||
val isEncrypted: Boolean = false,
|
||||
val deliveryStatus: DeliveryStatus? = null
|
||||
) : Parcelable {
|
||||
|
||||
/**
|
||||
* Convert message to binary payload format - exactly same as iOS version
|
||||
*/
|
||||
fun toBinaryPayload(): ByteArray? {
|
||||
try {
|
||||
val buffer = ByteBuffer.allocate(4096).apply { order(ByteOrder.BIG_ENDIAN) }
|
||||
|
||||
// Message format:
|
||||
// - Flags: 1 byte (bit flags for optional fields)
|
||||
// - Timestamp: 8 bytes (milliseconds since epoch, big-endian)
|
||||
// - ID length: 1 byte + ID data
|
||||
// - Sender length: 1 byte + sender data
|
||||
// - Content length: 2 bytes + content data (or encrypted content)
|
||||
// Optional fields based on flags...
|
||||
|
||||
var flags: UByte = 0u
|
||||
if (isRelay) flags = flags or 0x01u
|
||||
if (isPrivate) flags = flags or 0x02u
|
||||
if (originalSender != null) flags = flags or 0x04u
|
||||
if (recipientNickname != null) flags = flags or 0x08u
|
||||
if (senderPeerID != null) flags = flags or 0x10u
|
||||
if (mentions != null && mentions.isNotEmpty()) flags = flags or 0x20u
|
||||
if (channel != null) flags = flags or 0x40u
|
||||
if (isEncrypted) flags = flags or 0x80u
|
||||
|
||||
buffer.put(flags.toByte())
|
||||
|
||||
// Timestamp (in milliseconds, 8 bytes big-endian)
|
||||
val timestampMillis = timestamp.time
|
||||
buffer.putLong(timestampMillis)
|
||||
|
||||
// ID
|
||||
val idBytes = id.toByteArray(Charsets.UTF_8)
|
||||
buffer.put(minOf(idBytes.size, 255).toByte())
|
||||
buffer.put(idBytes.take(255).toByteArray())
|
||||
|
||||
// Sender
|
||||
val senderBytes = sender.toByteArray(Charsets.UTF_8)
|
||||
buffer.put(minOf(senderBytes.size, 255).toByte())
|
||||
buffer.put(senderBytes.take(255).toByteArray())
|
||||
|
||||
// Content or encrypted content
|
||||
if (isEncrypted && encryptedContent != null) {
|
||||
val length = minOf(encryptedContent.size, 65535)
|
||||
buffer.putShort(length.toShort())
|
||||
buffer.put(encryptedContent.take(length).toByteArray())
|
||||
} else {
|
||||
val contentBytes = content.toByteArray(Charsets.UTF_8)
|
||||
val length = minOf(contentBytes.size, 65535)
|
||||
buffer.putShort(length.toShort())
|
||||
buffer.put(contentBytes.take(length).toByteArray())
|
||||
}
|
||||
|
||||
// Optional fields
|
||||
originalSender?.let { origSender ->
|
||||
val origBytes = origSender.toByteArray(Charsets.UTF_8)
|
||||
buffer.put(minOf(origBytes.size, 255).toByte())
|
||||
buffer.put(origBytes.take(255).toByteArray())
|
||||
}
|
||||
|
||||
recipientNickname?.let { recipient ->
|
||||
val recipBytes = recipient.toByteArray(Charsets.UTF_8)
|
||||
buffer.put(minOf(recipBytes.size, 255).toByte())
|
||||
buffer.put(recipBytes.take(255).toByteArray())
|
||||
}
|
||||
|
||||
senderPeerID?.let { peerID ->
|
||||
val peerBytes = peerID.toByteArray(Charsets.UTF_8)
|
||||
buffer.put(minOf(peerBytes.size, 255).toByte())
|
||||
buffer.put(peerBytes.take(255).toByteArray())
|
||||
}
|
||||
|
||||
// Mentions array
|
||||
mentions?.let { mentionList ->
|
||||
buffer.put(minOf(mentionList.size, 255).toByte())
|
||||
mentionList.take(255).forEach { mention ->
|
||||
val mentionBytes = mention.toByteArray(Charsets.UTF_8)
|
||||
buffer.put(minOf(mentionBytes.size, 255).toByte())
|
||||
buffer.put(mentionBytes.take(255).toByteArray())
|
||||
}
|
||||
}
|
||||
|
||||
// Channel hashtag
|
||||
channel?.let { channelName ->
|
||||
val channelBytes = channelName.toByteArray(Charsets.UTF_8)
|
||||
buffer.put(minOf(channelBytes.size, 255).toByte())
|
||||
buffer.put(channelBytes.take(255).toByteArray())
|
||||
}
|
||||
|
||||
val result = ByteArray(buffer.position())
|
||||
buffer.rewind()
|
||||
buffer.get(result)
|
||||
return result
|
||||
|
||||
} catch (e: Exception) {
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
/**
|
||||
* Parse message from binary payload - exactly same logic as iOS version
|
||||
*/
|
||||
fun fromBinaryPayload(data: ByteArray): BitchatMessage? {
|
||||
try {
|
||||
if (data.size < 13) return null
|
||||
|
||||
val buffer = ByteBuffer.wrap(data).apply { order(ByteOrder.BIG_ENDIAN) }
|
||||
|
||||
// Flags
|
||||
val flags = buffer.get().toUByte()
|
||||
val isRelay = (flags and 0x01u) != 0u.toUByte()
|
||||
val isPrivate = (flags and 0x02u) != 0u.toUByte()
|
||||
val hasOriginalSender = (flags and 0x04u) != 0u.toUByte()
|
||||
val hasRecipientNickname = (flags and 0x08u) != 0u.toUByte()
|
||||
val hasSenderPeerID = (flags and 0x10u) != 0u.toUByte()
|
||||
val hasMentions = (flags and 0x20u) != 0u.toUByte()
|
||||
val hasChannel = (flags and 0x40u) != 0u.toUByte()
|
||||
val isEncrypted = (flags and 0x80u) != 0u.toUByte()
|
||||
|
||||
// Timestamp
|
||||
val timestampMillis = buffer.getLong()
|
||||
val timestamp = Date(timestampMillis)
|
||||
|
||||
// ID
|
||||
val idLength = buffer.get().toInt() and 0xFF
|
||||
if (buffer.remaining() < idLength) return null
|
||||
val idBytes = ByteArray(idLength)
|
||||
buffer.get(idBytes)
|
||||
val id = String(idBytes, Charsets.UTF_8)
|
||||
|
||||
// Sender
|
||||
val senderLength = buffer.get().toInt() and 0xFF
|
||||
if (buffer.remaining() < senderLength) return null
|
||||
val senderBytes = ByteArray(senderLength)
|
||||
buffer.get(senderBytes)
|
||||
val sender = String(senderBytes, Charsets.UTF_8)
|
||||
|
||||
// Content
|
||||
val contentLength = buffer.getShort().toInt() and 0xFFFF
|
||||
if (buffer.remaining() < contentLength) return null
|
||||
|
||||
val content: String
|
||||
val encryptedContent: ByteArray?
|
||||
|
||||
if (isEncrypted) {
|
||||
val encryptedBytes = ByteArray(contentLength)
|
||||
buffer.get(encryptedBytes)
|
||||
encryptedContent = encryptedBytes
|
||||
content = "" // Empty placeholder
|
||||
} else {
|
||||
val contentBytes = ByteArray(contentLength)
|
||||
buffer.get(contentBytes)
|
||||
content = String(contentBytes, Charsets.UTF_8)
|
||||
encryptedContent = null
|
||||
}
|
||||
|
||||
// Optional fields
|
||||
val originalSender = if (hasOriginalSender && buffer.hasRemaining()) {
|
||||
val length = buffer.get().toInt() and 0xFF
|
||||
if (buffer.remaining() >= length) {
|
||||
val bytes = ByteArray(length)
|
||||
buffer.get(bytes)
|
||||
String(bytes, Charsets.UTF_8)
|
||||
} else null
|
||||
} else null
|
||||
|
||||
val recipientNickname = if (hasRecipientNickname && buffer.hasRemaining()) {
|
||||
val length = buffer.get().toInt() and 0xFF
|
||||
if (buffer.remaining() >= length) {
|
||||
val bytes = ByteArray(length)
|
||||
buffer.get(bytes)
|
||||
String(bytes, Charsets.UTF_8)
|
||||
} else null
|
||||
} else null
|
||||
|
||||
val senderPeerID = if (hasSenderPeerID && buffer.hasRemaining()) {
|
||||
val length = buffer.get().toInt() and 0xFF
|
||||
if (buffer.remaining() >= length) {
|
||||
val bytes = ByteArray(length)
|
||||
buffer.get(bytes)
|
||||
String(bytes, Charsets.UTF_8)
|
||||
} else null
|
||||
} else null
|
||||
|
||||
// Mentions array
|
||||
val mentions = if (hasMentions && buffer.hasRemaining()) {
|
||||
val mentionCount = buffer.get().toInt() and 0xFF
|
||||
val mentionList = mutableListOf<String>()
|
||||
repeat(mentionCount) {
|
||||
if (buffer.hasRemaining()) {
|
||||
val length = buffer.get().toInt() and 0xFF
|
||||
if (buffer.remaining() >= length) {
|
||||
val bytes = ByteArray(length)
|
||||
buffer.get(bytes)
|
||||
mentionList.add(String(bytes, Charsets.UTF_8))
|
||||
}
|
||||
}
|
||||
}
|
||||
if (mentionList.isNotEmpty()) mentionList else null
|
||||
} else null
|
||||
|
||||
// Channel
|
||||
val channel = if (hasChannel && buffer.hasRemaining()) {
|
||||
val length = buffer.get().toInt() and 0xFF
|
||||
if (buffer.remaining() >= length) {
|
||||
val bytes = ByteArray(length)
|
||||
buffer.get(bytes)
|
||||
String(bytes, Charsets.UTF_8)
|
||||
} else null
|
||||
} else null
|
||||
|
||||
return BitchatMessage(
|
||||
id = id,
|
||||
sender = sender,
|
||||
content = content,
|
||||
timestamp = timestamp,
|
||||
isRelay = isRelay,
|
||||
originalSender = originalSender,
|
||||
isPrivate = isPrivate,
|
||||
recipientNickname = recipientNickname,
|
||||
senderPeerID = senderPeerID,
|
||||
mentions = mentions,
|
||||
channel = channel,
|
||||
encryptedContent = encryptedContent,
|
||||
isEncrypted = isEncrypted
|
||||
)
|
||||
|
||||
} catch (e: Exception) {
|
||||
return null
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun equals(other: Any?): Boolean {
|
||||
if (this === other) return true
|
||||
if (javaClass != other?.javaClass) return false
|
||||
|
||||
other as BitchatMessage
|
||||
|
||||
if (id != other.id) return false
|
||||
if (sender != other.sender) return false
|
||||
if (content != other.content) return false
|
||||
if (timestamp != other.timestamp) return false
|
||||
if (isRelay != other.isRelay) return false
|
||||
if (originalSender != other.originalSender) return false
|
||||
if (isPrivate != other.isPrivate) return false
|
||||
if (recipientNickname != other.recipientNickname) return false
|
||||
if (senderPeerID != other.senderPeerID) return false
|
||||
if (mentions != other.mentions) return false
|
||||
if (channel != other.channel) return false
|
||||
if (encryptedContent != null) {
|
||||
if (other.encryptedContent == null) return false
|
||||
if (!encryptedContent.contentEquals(other.encryptedContent)) return false
|
||||
} else if (other.encryptedContent != null) return false
|
||||
if (isEncrypted != other.isEncrypted) return false
|
||||
if (deliveryStatus != other.deliveryStatus) return false
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
override fun hashCode(): Int {
|
||||
var result = id.hashCode()
|
||||
result = 31 * result + sender.hashCode()
|
||||
result = 31 * result + content.hashCode()
|
||||
result = 31 * result + timestamp.hashCode()
|
||||
result = 31 * result + isRelay.hashCode()
|
||||
result = 31 * result + (originalSender?.hashCode() ?: 0)
|
||||
result = 31 * result + isPrivate.hashCode()
|
||||
result = 31 * result + (recipientNickname?.hashCode() ?: 0)
|
||||
result = 31 * result + (senderPeerID?.hashCode() ?: 0)
|
||||
result = 31 * result + (mentions?.hashCode() ?: 0)
|
||||
result = 31 * result + (channel?.hashCode() ?: 0)
|
||||
result = 31 * result + (encryptedContent?.contentHashCode() ?: 0)
|
||||
result = 31 * result + isEncrypted.hashCode()
|
||||
result = 31 * result + (deliveryStatus?.hashCode() ?: 0)
|
||||
return result
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Delivery acknowledgment structure - exact same as iOS version
|
||||
*/
|
||||
@Parcelize
|
||||
data class DeliveryAck(
|
||||
val originalMessageID: String,
|
||||
val ackID: String = UUID.randomUUID().toString(),
|
||||
val recipientID: String,
|
||||
val recipientNickname: String,
|
||||
val timestamp: Date = Date(),
|
||||
val hopCount: UByte
|
||||
) : Parcelable {
|
||||
|
||||
fun encode(): ByteArray? {
|
||||
return try {
|
||||
com.google.gson.Gson().toJson(this).toByteArray(Charsets.UTF_8)
|
||||
} catch (e: Exception) {
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
fun decode(data: ByteArray): DeliveryAck? {
|
||||
return try {
|
||||
val json = String(data, Charsets.UTF_8)
|
||||
com.google.gson.Gson().fromJson(json, DeliveryAck::class.java)
|
||||
} catch (e: Exception) {
|
||||
null
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read receipt structure - exact same as iOS version
|
||||
*/
|
||||
@Parcelize
|
||||
data class ReadReceipt(
|
||||
val originalMessageID: String,
|
||||
val receiptID: String = UUID.randomUUID().toString(),
|
||||
val readerID: String,
|
||||
val readerNickname: String,
|
||||
val timestamp: Date = Date()
|
||||
) : Parcelable {
|
||||
|
||||
fun encode(): ByteArray? {
|
||||
return try {
|
||||
com.google.gson.Gson().toJson(this).toByteArray(Charsets.UTF_8)
|
||||
} catch (e: Exception) {
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
fun decode(data: ByteArray): ReadReceipt? {
|
||||
return try {
|
||||
val json = String(data, Charsets.UTF_8)
|
||||
com.google.gson.Gson().fromJson(json, ReadReceipt::class.java)
|
||||
} catch (e: Exception) {
|
||||
null
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user