diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index b589d56e..b86273d9 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -1,6 +1,6 @@
-
+
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 0897082f..639c779c 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -4,6 +4,7 @@
-
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index b67486ec..bb270b80 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -3,15 +3,19 @@
+
+
+
+
@@ -33,6 +37,10 @@
+
+
+
+
@@ -57,6 +65,10 @@
+
+
+
+
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 8978d23d..0bd3ec25 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,6 +1,5 @@
-
-
+
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 8f60d557..5a8595a8 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -8,7 +8,7 @@ plugins {
android {
namespace = "com.greybox.projectmesh"
- compileSdk = 34
+ compileSdk = 35
defaultConfig {
applicationId = "com.greybox.projectmesh"
@@ -30,6 +30,13 @@ android {
getDefaultProguardFile("proguard-android-optimize.txt"),
"proguard-rules.pro"
)
+ signingConfig = signingConfigs.getByName("debug")
+ }
+
+ debug {
+ isDebuggable = true
+ applicationIdSuffix = ".debug"
+ versionNameSuffix = "-debug"
}
}
compileOptions {
@@ -70,6 +77,7 @@ dependencies {
implementation("androidx.compose.material3:material3:1.2.1")
implementation("androidx.compose.material:material-icons-core:1.6.8")
implementation("androidx.compose.material:material-icons-extended-android:1.6.8")
+ implementation(libs.androidx.foundation)
implementation(libs.androidx.ui)
implementation(libs.androidx.ui.graphics)
implementation(libs.androidx.ui.tooling.preview)
@@ -144,4 +152,7 @@ dependencies {
// For JSON serialisation
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
+
+ // For Debug Build
+ implementation("com.jakewharton.timber:timber:5.0.1")
}
\ No newline at end of file
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 9896e93f..99119f3b 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -74,7 +74,7 @@
android:name=".MainActivity"
android:exported="true"
android:label="@string/app_name"
- android:theme="@style/Theme.ProjectMesh">
+ android:theme="@style/Theme.ProjectMesh.Launcher">
@@ -83,7 +83,7 @@
diff --git a/app/src/main/java/com/greybox/projectmesh/DeviceStatusManager.kt b/app/src/main/java/com/greybox/projectmesh/DeviceStatusManager.kt
new file mode 100644
index 00000000..53cde4dd
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/DeviceStatusManager.kt
@@ -0,0 +1,322 @@
+package com.greybox.projectmesh
+
+import android.util.Log
+import com.greybox.projectmesh.server.AppServer
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
+import java.net.InetAddress
+
+/**
+ * Centralized manager for tracking online/offline status of devices.
+ * This singleton provides a single source of truth that can be observed by different parts of the app.
+ */
+
+object DeviceStatusManager {
+ //private mutable state flow that stores device IP address to online status mapping
+ private val _deviceStatusMap = MutableStateFlow>(emptyMap())
+
+ //public read only state flow for detection
+ val deviceStatusMap: StateFlow> = _deviceStatusMap.asStateFlow()
+
+ // min time between status checks
+ private const val MIN_STATUS_CHECK_INTERVAL = 5000L
+
+ //map to track when a device was last checked
+ private val lastCheckedTimes = mutableMapOf()
+
+ //coroutine scope for background operations
+ private val scope = CoroutineScope(Dispatchers.IO + Job())
+
+ //reference to AppServer - will be set during initialization
+ private var appServer: AppServer? = null
+
+ //track consecutive failures
+ private val failureCountMap = mutableMapOf()
+
+ //special test device addresses that should be handled differently
+ private val specialDevices = setOf(
+ "192.168.0.99", // Online test device
+ "192.168.0.98" // Offline test device
+ )
+
+ //initialize the device status manager with necessary dependencies
+ fun initialize(server: AppServer) {
+ appServer = server
+
+ // Start periodic background checks
+ startPeriodicStatusChecks()
+ }
+
+ fun updateDeviceStatus(ipAddress: String, isOnline: Boolean, verified: Boolean = false) {
+ //if this is a special device, handle according to its predefined status
+ if (ipAddress == "192.168.0.99") { // Online test device
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = true
+ mutable
+ }
+ Log.d("DeviceStatusManager", "Updated test device status for $ipAddress: online")
+ return
+ } else if (ipAddress == "192.168.0.98") { // Offline test device
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = false
+ mutable
+ }
+ Log.d("DeviceStatusManager", "Updated test device status for $ipAddress: offline")
+ return
+ }
+
+ //for normal devices, if the update is verified (from a trusted component), update immediately
+ if (verified) {
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = isOnline
+ Log.d("DeviceStatusManager", "Updated verified status for $ipAddress: ${if (isOnline) "online" else "offline"}")
+ mutable
+ }
+ //also update the last checked time
+ lastCheckedTimes[ipAddress] = System.currentTimeMillis()
+ } else {
+ //if not verified, only change offline->online (we'll verify before changing online->offline)
+ if (isOnline && (!_deviceStatusMap.value.containsKey(ipAddress) || _deviceStatusMap.value[ipAddress] == false)) {
+ // Only update if we're going from offline/unknown to online
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = true
+ Log.d("DeviceStatusManager", "Updated status for $ipAddress: online (unverified)")
+ mutable
+ }
+
+ //schedule a verification check to confirm it's really online
+ verifyDeviceStatus(ipAddress)
+ } else if (!isOnline) {
+ //for marking devices offline, we need verification
+ verifyDeviceStatus(ipAddress)
+ }
+ }
+ }
+
+ //check if a device is currently online
+ fun isDeviceOnline(ipAddress: String): Boolean {
+ // Check if it's time to verify this device again
+ val lastChecked = lastCheckedTimes[ipAddress] ?: 0L
+ val now = System.currentTimeMillis()
+
+ if (now - lastChecked > MIN_STATUS_CHECK_INTERVAL &&
+ _deviceStatusMap.value[ipAddress] == true) {
+ // If it's been a while since we checked and device is marked online, verify
+ verifyDeviceStatus(ipAddress)
+ }
+
+ return _deviceStatusMap.value[ipAddress] ?: false
+ }
+
+
+ //verify if a device is actually online by attempting to connect
+ fun verifyDeviceStatus(ipAddress: String) {
+ // Skip verification for special test devices
+ if (ipAddress in specialDevices) {
+ return
+ }
+
+ // Check if we've verified recently
+ val lastChecked = lastCheckedTimes[ipAddress] ?: 0L
+ val now = System.currentTimeMillis()
+
+ if (now - lastChecked < MIN_STATUS_CHECK_INTERVAL) {
+ // Checked too recently, skip
+ return
+ }
+
+ scope.launch {
+ // Add a log to track verification attempts
+ Log.d("DeviceStatusManager", "Verifying device status for $ipAddress")
+
+ lastCheckedTimes[ipAddress] = System.currentTimeMillis()
+
+ try {
+ // IMPORTANT: Check if there are any recent messages from this device
+ // This information is maintained in NetworkScreenViewModel
+ // We can check if the IP is in the current known nodes list
+
+ // Instead of directly accessing originatorMessages, we'll use the current
+ // deviceStatusMap to see if the device was marked as online by any component
+ val isCurrentlyOnline = _deviceStatusMap.value[ipAddress] ?: false
+
+ // If the device was marked as online by any component and we're doing
+ // a verification check, give it more attempts before marking offline
+ val attemptsNeeded = if (isCurrentlyOnline) 3 else 1
+
+ val addr = InetAddress.getByName(ipAddress)
+ val isReachable = withTimeoutOrNull(3000) {
+ addr.isReachable(2000)
+ } ?: false
+
+ if (isReachable) {
+ // Reset failure count if reachable
+ failureCountMap.remove(ipAddress)
+
+ // Update status to online
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = true
+ Log.d("DeviceStatusManager", "Device $ipAddress is reachable, marking online")
+ mutable
+ }
+ } else {
+ // Not reachable - increment failure count
+ val failures = (failureCountMap[ipAddress] ?: 0) + 1
+ failureCountMap[ipAddress] = failures
+
+ // Only mark as offline after multiple consecutive failures
+ if (failures >= attemptsNeeded) {
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = false
+ Log.d("DeviceStatusManager",
+ "Device $ipAddress is unreachable after $failures attempts, marking offline")
+ mutable
+ }
+ } else {
+ Log.d("DeviceStatusManager",
+ "Device $ipAddress is unreachable (attempt $failures/$attemptsNeeded), still considered online")
+ }
+ }
+
+ // Then try the app-level check if the device is believed to be online
+ if (isReachable || (isCurrentlyOnline && failureCountMap[ipAddress] ?: 0 < attemptsNeeded)) {
+ appServer?.let { server ->
+ // Only do this check if we have the AppServer instance
+ try {
+ // Try a quick check to app server endpoints
+ val checkResult = server.checkDeviceReachable(addr)
+
+ if (checkResult) {
+ // Reset failure count on successful app-level check
+ failureCountMap.remove(ipAddress)
+
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = true
+ Log.d("DeviceStatusManager",
+ "App-level check for $ipAddress successful, marking online")
+ mutable
+ }
+
+ // If device is online, update user info and conversation status
+ server.requestRemoteUserInfo(addr)
+ }else {
+ //do nothing
+ }
+ } catch (e: Exception) {
+ // Log but don't immediately change status based on this check
+ Log.d("DeviceStatusManager", "App-level check for $ipAddress failed: ${e.message}")
+ }
+ }
+ }
+ } catch (e: Exception) {
+ // If any exception occurs, log but don't immediately mark as offline
+ Log.d("DeviceStatusManager", "Error checking device $ipAddress: ${e.message}")
+
+ // Increment failure count
+ val failures = (failureCountMap[ipAddress] ?: 0) + 1
+ failureCountMap[ipAddress] = failures
+
+ // Mark as offline after 3 consecutive failures
+ if (failures >= 3) {
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = false
+ Log.d("DeviceStatusManager",
+ "Device $ipAddress has $failures consecutive failures, marking offline")
+ mutable
+ }
+ }
+ }
+ }
+ }
+
+ fun handleNetworkDisconnect(ipAddress: String) {
+ Log.d("DeviceStatusManager", "Network layer reported disconnect for $ipAddress, immediately updating status")
+
+ // Skip for special test devices
+ if (ipAddress in specialDevices) {
+ return
+ }
+
+ // Immediately update status to offline
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = false
+ mutable
+ }
+
+ // Reset failure count
+ failureCountMap.remove(ipAddress)
+
+ // Update conversations immediately
+ updateConversations(ipAddress, false)
+ }
+
+ // Helper method to update conversations when device status changes
+ private fun updateConversations(ipAddress: String, isOnline: Boolean) {
+ scope.launch {
+ try {
+ // Get user by IP
+ val user = GlobalApp.GlobalUserRepo.userRepository.getUserByIp(ipAddress)
+ if (user != null) {
+ // Update conversation status
+ GlobalApp.GlobalUserRepo.conversationRepository.updateUserStatus(
+ userUuid = user.uuid,
+ isOnline = isOnline,
+ userAddress = if (isOnline) ipAddress else null
+ )
+ Log.d("DeviceStatusManager", "Updated conversation status for ${user.name}: online=$isOnline")
+ }
+ } catch (e: Exception) {
+ Log.e("DeviceStatusManager", "Error updating conversation for $ipAddress", e)
+ }
+ }
+ }
+
+ //get all online devices
+ fun getOnlineDevices(): List {
+ return _deviceStatusMap.value.filter { it.value }.keys.toList()
+ }
+
+ //clear all device statuses
+ //use when restarting app or when network changes alot
+ fun clearAllStatuses() {
+ _deviceStatusMap.value = emptyMap()
+ lastCheckedTimes.clear()
+ Log.d("DeviceStatusManager", "Cleared all device statuses")
+ }
+
+ //Start periodic background checks for device status
+ private fun startPeriodicStatusChecks() {
+ scope.launch {
+ while (true) {
+ // Check all devices marked as online
+ _deviceStatusMap.value.filter { it.value }.keys.forEach { ipAddress ->
+ // Skip special devices
+ if (ipAddress !in specialDevices) {
+ verifyDeviceStatus(ipAddress)
+ }
+ }
+
+ // Wait between check cycles
+ delay(30000) // 30 seconds between checks
+ }
+ }
+ }
+
+}
diff --git a/app/src/main/java/com/greybox/projectmesh/GlobalApp.kt b/app/src/main/java/com/greybox/projectmesh/GlobalApp.kt
index 5fcc6c78..7f22e149 100644
--- a/app/src/main/java/com/greybox/projectmesh/GlobalApp.kt
+++ b/app/src/main/java/com/greybox/projectmesh/GlobalApp.kt
@@ -1,20 +1,29 @@
package com.greybox.projectmesh
+import android.annotation.SuppressLint
import android.app.Application
import android.content.Context
import android.content.SharedPreferences
+import android.os.Build
+import android.os.Environment
import android.util.Log
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.intPreferencesKey
import androidx.room.Room
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
import com.greybox.projectmesh.db.MeshDatabase
+import com.greybox.projectmesh.extension.deviceInfo
+import com.greybox.projectmesh.messaging.repository.ConversationRepository
import com.greybox.projectmesh.extension.networkDataStore
import com.greybox.projectmesh.server.AppServer
import com.ustadmobile.meshrabiya.ext.addressToDotNotation
import com.ustadmobile.meshrabiya.ext.asInetAddress
+import com.ustadmobile.meshrabiya.ext.requireAddressAsInt
import com.ustadmobile.meshrabiya.vnet.AndroidVirtualNode
import com.ustadmobile.meshrabiya.vnet.randomApipaAddr
import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.launch
@@ -29,8 +38,18 @@ import org.kodein.di.singleton
import java.io.File
import java.net.InetAddress
import java.time.Duration
+import java.util.UUID
import java.util.concurrent.ConcurrentHashMap
+import com.greybox.projectmesh.user.UserRepository
+import com.greybox.projectmesh.messaging.data.entities.Message
+import com.greybox.projectmesh.messaging.utils.MessageMigrationUtils
+import com.greybox.projectmesh.testing.TestDeviceService
+import com.greybox.projectmesh.user.UserEntity
+import com.ustadmobile.meshrabiya.log.MNetLogger
+import java.text.SimpleDateFormat
+import java.util.Date
+
/*
initialize global variables and DI(dependency injection) container
why use DI?
@@ -39,7 +58,7 @@ All dependencies are defined in one place, which makes it easier to manage and t
class GlobalApp : Application(), DIAware {
// it is an instance of Preferences.key, used to interact with "DataStore"
private val addressKey = intPreferencesKey("virtual_node_address")
- data object DeviceInfoManager {
+ /*data object DeviceInfoManager {
// Global HashMap to store IP-DeviceName mapping
private val deviceNameMap = ConcurrentHashMap()
@@ -63,7 +82,177 @@ class GlobalApp : Application(), DIAware {
fun getChatName(inetAddress: InetAddress): String {
return inetAddress.hostAddress
}
+ }*/
+ object GlobalUserRepo {
+ // Lateinit or lazy property
+ lateinit var userRepository: UserRepository
+ lateinit var prefs: SharedPreferences
+ lateinit var conversationRepository: ConversationRepository
+ }
+ override fun onCreate() {
+ super.onCreate()
+ val sharedPrefs: SharedPreferences by di.instance(tag = "settings")
+ val uuid = sharedPrefs.getString("UUID", null)
+ if (uuid == null) {
+ // Generate a new UUID if one doesn't exist
+ val newUuid = java.util.UUID.randomUUID().toString()
+ sharedPrefs.edit().putString("UUID", newUuid).apply()
+ Log.d("GlobalApp", "Generated new UUID: $newUuid")
+ }
+
+ //get the repositories from DI
+ val repo: UserRepository by di.instance()
+ GlobalUserRepo.userRepository = repo
+ GlobalUserRepo.prefs = sharedPrefs
+
+ val convRepo: ConversationRepository by di.instance()
+ GlobalUserRepo.conversationRepository = convRepo
+
+ //initialize deviceStatus Manager:
+ val appServer: AppServer by di.instance()
+ DeviceStatusManager.initialize(appServer)
+
+ //version checking migrating messages
+ val hasMigratedMessages = sharedPrefs.getBoolean("has_migrated_messages", false)
+ if (!hasMigratedMessages) {
+ GlobalScope.launch {
+ try {
+ Log.d("GlobalApp", "Starting message migration...")
+ val migrationUtils = MessageMigrationUtils(di)
+ migrationUtils.migrateMessagesToChatIds()
+ // Mark migration as complete
+ sharedPrefs.edit().putBoolean("has_migrated_messages", true).apply()
+ Log.d("GlobalApp", "Message migration completed and marked as done")
+ } catch (e: Exception) {
+ Log.e("GlobalApp", "Error during message migration", e)
+ // Don't mark as complete if there was an error
+ }
+ }
+ } else {
+ Log.d("GlobalApp", "Message migration already performed, skipping")
+ }
+
+ //add test convos
+ insertTestConversations()
}
+
+ fun insertTestConversations() {
+ GlobalScope.launch {
+ try {
+ //get database instance
+ val db: MeshDatabase by di.instance()
+
+ // Check if any messages exist first
+ val existingMessages = db.messageDao().getAll()
+ Log.d("GlobalApp", "Found ${existingMessages.size} existing messages")
+
+ if (existingMessages.isEmpty()) {
+ Log.d("GlobalApp", "No messages found, creating test messages...")
+
+ val localUuid = GlobalUserRepo.prefs.getString("UUID", null) ?: "local-user"
+
+ //insert test convo with online test device
+ val testDevice = TestDeviceService.getTestDeviceAddress()
+ val testUser = UserEntity(
+ uuid = "test-device-uuid",
+ name = TestDeviceService.TEST_DEVICE_NAME,
+ address = testDevice.hostAddress
+ )
+
+ //make sure the test user exists in the database
+ GlobalUserRepo.userRepository.insertOrUpdateUser(
+ testUser.uuid,
+ testUser.name,
+ testUser.address
+ )
+
+ //create convo with the test device
+ val onlineConversation =
+ GlobalUserRepo.conversationRepository.getOrCreateConversation(
+ localUuid = localUuid,
+ remoteUser = testUser
+ )
+
+ //create online test message
+ val onlineTestMessage = Message(
+ id = 0,
+ dateReceived = System.currentTimeMillis() - 3600000, // 1 hour ago
+ content = "Hello world! This is a test message.",
+ sender = TestDeviceService.TEST_DEVICE_NAME,
+ chat = "local-user-test-device-uuid" // Use ONLY conversation ID format
+ )
+
+ //insert the message
+ db.messageDao().addMessage(onlineTestMessage)
+
+ Log.d(
+ "GlobalApp",
+ "Inserted online test message with chat name: local-user-test-device-uuid"
+ )
+
+ //update convo with a test message
+ GlobalUserRepo.conversationRepository.updateWithMessage(
+ conversationId = onlineConversation.id,
+ message = onlineTestMessage
+ )
+
+ //create offline test user and conversation
+ val offlineUser = UserEntity(
+ uuid = "offline-test-device-uuid",
+ name = TestDeviceService.TEST_DEVICE_NAME_OFFLINE,
+ address = null // null address means offline
+ )
+
+ //make sure the offline test user exists in the database
+ GlobalUserRepo.userRepository.insertOrUpdateUser(
+ offlineUser.uuid,
+ offlineUser.name,
+ offlineUser.address
+ )
+
+ //create convo with the offline test device
+ val offlineConversation =
+ GlobalUserRepo.conversationRepository.getOrCreateConversation(
+ localUuid = localUuid,
+ remoteUser = offlineUser
+ )
+
+ //create offline test message - use ONLY the conversation ID format
+ val offlineTestMessage = Message(
+ id = 0,
+ dateReceived = System.currentTimeMillis() - 3600000, // 1 hour ago
+ content = "I'm currently offline. Messages won't be delivered.",
+ sender = TestDeviceService.TEST_DEVICE_NAME_OFFLINE,
+ chat = "local-user-offline-test-device-uuid" // Use ONLY conversation ID format
+ )
+
+ //update test device statuses
+ DeviceStatusManager.updateDeviceStatus(TestDeviceService.TEST_DEVICE_IP, true)
+ DeviceStatusManager.updateDeviceStatus(TestDeviceService.TEST_DEVICE_IP_OFFLINE, false)
+
+ // Insert the message
+ db.messageDao().addMessage(offlineTestMessage)
+
+ Log.d(
+ "GlobalApp",
+ "Inserted offline test message with chat name: local-user-offline-test-device-uuid"
+ )
+
+ //update convo with the message
+ GlobalUserRepo.conversationRepository.updateWithMessage(
+ conversationId = offlineConversation.id,
+ message = offlineTestMessage
+ )
+ Log.d("GlobalApp", "Test messages inserted successfully")
+ }else {
+ Log.d("GlobalApp", "Messages already exist, skipping insertion")
+ }
+ }catch (e: Exception ) {
+ Log.e("GlobalApp", "Error inserting test conversation", e)
+ }
+ }
+ }
+ @SuppressLint("SimpleDateFormat")
private val diModule = DI.Module("project_mesh") {
// create a single instance of "InetAddress" for the entire lifetime of the application
bind(tag=TAG_VIRTUAL_ADDRESS) with singleton {
@@ -91,11 +280,25 @@ class GlobalApp : Application(), DIAware {
}
}
}
+ bind() with singleton {
+ val logFileNameDateComp = SimpleDateFormat("yyyyMMdd_HHmmss").format(Date())
+ val logDir: File = instance(tag = TAG_LOG_DIR)
+ MNetLoggerAndroid(
+ deviceInfo = deviceInfo(),
+ minLogLevel = Log.DEBUG,
+ logFile = File(logDir, "${logFileNameDateComp}_${Build.MANUFACTURER}_${Build.MODEL}.log")
+ )
+ }
bind () with singleton {
Json {
encodeDefaults = true
}
}
+
+ bind(tag = TAG_LOG_DIR) with singleton {
+ File(filesDir, "log")
+ }
+
/*
Ensuring a directory named "www" was created
*/
@@ -115,6 +318,7 @@ class GlobalApp : Application(), DIAware {
// initialize the AndroidVirtualNode Constructor
AndroidVirtualNode(
appContext = applicationContext,
+ logger = instance(),
json = instance(),
// inject the "InetAddress" instance
address = instance(tag = TAG_VIRTUAL_ADDRESS),
@@ -140,7 +344,27 @@ class GlobalApp : Application(), DIAware {
MeshDatabase::class.java,
"mesh-database"
)
- .fallbackToDestructiveMigration() // add this line to handle migrations destructively
+ .addMigrations(object : Migration(3,4){
+ override fun migrate(database: SupportSQLiteDatabase){
+
+ //create convo table
+ database.execSQL(
+ """
+ CREATE TABLE IF NOT EXISTS conversations (
+ id TEXT PRIMARY KEY NOT NULL,
+ user_uuid TEXT NOT NULL,
+ user_name TEXT NOT NULL,
+ user_address TEXT,
+ last_message TEXT,
+ last_message_time INTEGER NOT NULL,
+ unread_count INTEGER NOT NULL DEFAULT 0,
+ is_online INTEGER NOT NULL DEFAULT 0
+ )
+ """
+ )
+ }
+ })
+ .fallbackToDestructiveMigration() // handle migrations destructively
// .allowMainThreadQueries() // this should generally be avoided for production apps
.build()
}
@@ -148,29 +372,39 @@ class GlobalApp : Application(), DIAware {
bind(tag = "settings") with singleton {
applicationContext.getSharedPreferences("settings", Context.MODE_PRIVATE)
}
+ bind() with singleton {
+ UserRepository(instance().userDao())
+ }
+
+ bind() with singleton {
+ ConversationRepository(instance().conversationDao(), di)
+ }
bind() with singleton {
val node: AndroidVirtualNode = instance()
AppServer(
appContext = applicationContext,
httpClient = instance(),
+ mLogger = instance(),
port = AppServer.DEFAULT_PORT,
name = node.addressAsInt.addressToDotNotation(),
localVirtualAddr = node.address,
receiveDir = instance(tag = TAG_RECEIVE_DIR),
json = instance(),
di = di,
- db = instance()
+ db = instance(),
+ userRepository = instance()
)
}
onReady {
// clears all data in the existing tables
- GlobalScope.launch {
- instance().messageDao().clearTable()
- }
+ //GlobalScope.launch {
+ // instance().messageDao().clearTable()
+ //}
+ val logger: MNetLogger = instance()
instance().start()
- Log.d("AppServer", "Server started successfully on port: ${AppServer.DEFAULT_PORT}")
+ logger(Log.DEBUG,"AppServer started successfully on Port: ${AppServer.DEFAULT_PORT}")
}
}
@@ -183,5 +417,6 @@ class GlobalApp : Application(), DIAware {
const val TAG_VIRTUAL_ADDRESS = "virtual_address"
const val TAG_RECEIVE_DIR = "receive_dir"
const val TAG_WWW_DIR = "www_dir"
+ const val TAG_LOG_DIR = "log_dir"
}
}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/MNetLoggerAndroid.kt b/app/src/main/java/com/greybox/projectmesh/MNetLoggerAndroid.kt
new file mode 100644
index 00000000..e31dd461
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/MNetLoggerAndroid.kt
@@ -0,0 +1,106 @@
+package com.greybox.projectmesh
+
+import android.content.Context
+import android.util.Log
+import com.greybox.projectmesh.extension.deviceInfo
+import com.ustadmobile.meshrabiya.MeshrabiyaConstants
+import com.ustadmobile.meshrabiya.ext.trimIfExceeds
+import com.ustadmobile.meshrabiya.log.LogLine
+import com.ustadmobile.meshrabiya.log.MNetLogger
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import java.io.File
+import java.text.DateFormat
+import java.util.Date
+
+class MNetLoggerAndroid(
+ private val deviceInfo: String,
+ private val minLogLevel: Int = Log.VERBOSE,
+ private val logHistoryLines: Int = 300,
+ private val logFile: File? = null,
+): MNetLogger() {
+ val epochTime = System.currentTimeMillis()
+
+ private val _recentLogs = MutableStateFlow(emptyList())
+
+ val recentLogs: Flow> = _recentLogs.asStateFlow()
+
+ private val logScope = CoroutineScope(Dispatchers.IO + Job())
+
+ private val logChannel = Channel(Channel.UNLIMITED)
+
+ init {
+ logScope.launch {
+ logFile?.parentFile?.takeIf { !it.exists() }?.mkdirs()
+ val startTime = DateFormat.getTimeInstance().format(Date())
+ logFile?.appendText("Meshrabiya Session start: $startTime\n$deviceInfo\n")
+
+ for(logLine in logChannel) {
+ val time = (System.currentTimeMillis() - epochTime) / 1000.toFloat()
+ val rounded = (time * 100).toInt() / 100.toFloat()
+ logFile?.appendText("${priorityLabel(logLine.priority)}: t+${rounded}s : ${logLine.line}\n")
+ }
+ }
+ }
+
+ private fun doLog(priority: Int, message: String, exception: Exception?) {
+ when (priority) {
+ Log.VERBOSE -> Timber.tag(MeshrabiyaConstants.LOG_TAG).v(exception, message)
+ Log.DEBUG -> Timber.tag(MeshrabiyaConstants.LOG_TAG).d(exception, message)
+ Log.INFO -> Timber.tag(MeshrabiyaConstants.LOG_TAG).i(exception, message)
+ Log.WARN -> Timber.tag(MeshrabiyaConstants.LOG_TAG).w(exception, message)
+ Log.ERROR -> Timber.tag(MeshrabiyaConstants.LOG_TAG).e(exception, message)
+ Log.ASSERT -> Timber.tag(MeshrabiyaConstants.LOG_TAG).wtf(exception, message)
+ }
+
+ val logDisplay = buildString {
+ append(message)
+ if (exception != null) {
+ append(" Exception: ")
+ append(exception.toString())
+ }
+ }
+
+ val logLine = LogLine(logDisplay, priority, System.currentTimeMillis())
+ _recentLogs.update { prev ->
+ buildList {
+ add(logLine)
+ addAll(prev.trimIfExceeds(logHistoryLines - 1))
+ }
+ }
+ logChannel.takeIf { logFile != null }?.trySend(logLine)
+ }
+
+ override fun invoke(priority: Int, message: () -> String, exception: Exception?) {
+ if(priority >= minLogLevel)
+ doLog(priority, message(), exception)
+ }
+
+ override fun invoke(priority: Int, message: String, exception: Exception?) {
+ if(priority >= minLogLevel)
+ doLog(priority, message, exception)
+ }
+
+ /**
+ * Export logs with time/date stamp, device info, etc.
+ */
+ fun exportAsString(context: Context): String {
+ return buildString {
+ append(context.deviceInfo())
+ append("==Logs==\n")
+
+ _recentLogs.value.reversed().forEach {
+ append(it.toString(epochTime))
+ append("\n")
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/MainActivity.kt b/app/src/main/java/com/greybox/projectmesh/MainActivity.kt
index 5de79a1f..14e9703e 100644
--- a/app/src/main/java/com/greybox/projectmesh/MainActivity.kt
+++ b/app/src/main/java/com/greybox/projectmesh/MainActivity.kt
@@ -1,15 +1,27 @@
package com.greybox.projectmesh
+import android.annotation.SuppressLint
+import android.app.AlertDialog
+import android.content.Context
+import android.content.Context.MODE_PRIVATE
+import android.content.Intent
import android.content.SharedPreferences
+import android.net.Uri
import android.os.Build
import android.os.Bundle
import android.os.Environment
+import android.os.PowerManager
+import android.provider.Settings
import android.util.Log
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextField
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
@@ -27,14 +39,13 @@ import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import com.greybox.projectmesh.debug.CrashHandler
import com.greybox.projectmesh.debug.CrashScreenActivity
-import com.greybox.projectmesh.navigation.BottomNavApp
import com.greybox.projectmesh.navigation.BottomNavItem
import com.greybox.projectmesh.navigation.BottomNavigationBar
import com.greybox.projectmesh.server.AppServer
import com.greybox.projectmesh.ui.theme.AppTheme
import com.greybox.projectmesh.ui.theme.ProjectMeshTheme
import com.greybox.projectmesh.viewModel.SharedUriViewModel
-import com.greybox.projectmesh.views.ChatScreen
+import com.greybox.projectmesh.messaging.ui.screens.ChatScreen
import com.greybox.projectmesh.views.HomeScreen
import com.greybox.projectmesh.views.SettingsScreen
import com.greybox.projectmesh.views.NetworkScreen
@@ -42,6 +53,8 @@ import com.greybox.projectmesh.views.PingScreen
import com.greybox.projectmesh.views.ReceiveScreen
import com.greybox.projectmesh.views.SelectDestNodeScreen
import com.greybox.projectmesh.views.SendScreen
+import com.greybox.projectmesh.views.OnboardingScreen
+import com.greybox.projectmesh.testing.TestDeviceService
import org.kodein.di.DI
import org.kodein.di.DIAware
import org.kodein.di.android.closestDI
@@ -50,42 +63,97 @@ import org.kodein.di.instance
import java.io.File
import java.util.Locale
import java.net.InetAddress
+import com.greybox.projectmesh.messaging.ui.screens.ChatNodeListScreen
+import com.greybox.projectmesh.messaging.ui.screens.ConversationsHomeScreen
+import com.greybox.projectmesh.user.UserRepository
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.remember
+import kotlinx.coroutines.launch
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.platform.LocalSavedStateRegistryOwner
+import androidx.lifecycle.lifecycleScope
+import com.greybox.projectmesh.logging.ReleaseTree
+import kotlinx.coroutines.launch
+import com.greybox.projectmesh.messaging.data.entities.Conversation
+import com.greybox.projectmesh.messaging.ui.viewmodels.ChatScreenViewModel
+import com.greybox.projectmesh.views.LogScreen
+
+
import com.greybox.projectmesh.views.RequestPermissionsScreen
+import org.kodein.di.android.BuildConfig
+import org.kodein.di.compose.localDI
+
+import timber.log.Timber
class MainActivity : ComponentActivity(), DIAware {
override val di by closestDI()
override fun onCreate(savedInstanceState: Bundle?) {
+ setTheme(R.style.Theme_ProjectMesh)
super.onCreate(savedInstanceState)
+
+ // Init Timber for Debug Build
+ if (BuildConfig.DEBUG) {
+ Timber.plant(Timber.DebugTree())
+ } else {
+ Timber.plant(ReleaseTree())
+ }
+
+ Timber.d("Timber init in ${BuildConfig.BUILD_TYPE}")
+
// crash screen
- CrashHandler.init(applicationContext,CrashScreenActivity::class.java)
- val settingPref: SharedPreferences by di.instance(tag="settings")
+ CrashHandler.init(applicationContext, CrashScreenActivity::class.java)
+ val settingPref: SharedPreferences by di.instance(tag = "settings")
val appServer: AppServer by di.instance()
- // check if the default directory exist (Download/Project Mesh)
- ensureDefaultDirectory()
+ // Run this task asynchronously (default directory creation)
+ lifecycleScope.launch(Dispatchers.IO) {
+ ensureDefaultDirectory()
+ }
+ //Initialize test device:
+ TestDeviceService.initialize()
+ Timber.tag("MainActivity").d("Test device initialized")
+
setContent {
+ val meshPrefs = getSharedPreferences("project_mesh_prefs", MODE_PRIVATE)
+ var hasRunBefore by rememberSaveable {
+ mutableStateOf(meshPrefs.getBoolean("hasRunBefore", false))
+ }
// Check if the app was launched from a notification
val launchedFromNotification = intent?.getBooleanExtra("from_notification", false) ?: false
// Request all permission in order
RequestPermissionsScreen(skipPermissions = launchedFromNotification)
- var appTheme by rememberSaveable {
+ var appTheme by remember {
mutableStateOf(AppTheme.valueOf(
settingPref.getString("app_theme", AppTheme.SYSTEM.name) ?:
AppTheme.SYSTEM.name))
}
- var languageCode by rememberSaveable {
+ var languageCode by remember {
mutableStateOf(settingPref.getString(
"language", "en") ?: "en")
}
- var restartServerKey by rememberSaveable {mutableStateOf(0)}
- var deviceName by rememberSaveable {
+ var restartServerKey by remember {mutableStateOf(0)}
+ var deviceName by remember {
mutableStateOf(settingPref.getString("device_name", Build.MODEL) ?: Build.MODEL)
}
- var autoFinish by rememberSaveable {
+ var autoFinish by remember {
mutableStateOf(settingPref.getBoolean("auto_finish", false))
}
- var saveToFolder by rememberSaveable {
+ var saveToFolder by remember {
mutableStateOf(
settingPref.getString("save_to_folder", null)
?: "${Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)}/Project Mesh"
@@ -102,6 +170,33 @@ class MainActivity : ComponentActivity(), DIAware {
currentScreen = BottomNavItem.Receive.route
}
}
+
+ //check for special navigation intents
+ val action = intent.action
+ if (action == "OPEN_CHAT_SCREEN") {
+ val ip = intent.getStringExtra("ip")
+ if (ip != null) {
+ try {
+ // Try to create InetAddress to validate it first
+ InetAddress.getByName(ip)
+ // If that succeeds, navigate to chat screen with this IP
+ val route = "chatScreen/$ip"
+ currentScreen = route
+ } catch (e: Exception) {
+ Timber.tag("MainActivity").e(e, "Invalid IP address in intent: %s", ip)
+ // Fall back to home screen
+ currentScreen = BottomNavItem.Home.route
+ }
+ }
+ } else if (action == "OPEN_CHAT_CONVERSATION") {
+ val conversationId = intent.getStringExtra("conversationId")
+ if (conversationId != null) {
+ // Navigate to chat screen with this conversation ID
+ val route = "chatScreen/$conversationId"
+ currentScreen = route
+ }
+ }
+
LaunchedEffect(restartServerKey) {
if (restartServerKey > 0){
appServer.restart()
@@ -114,22 +209,31 @@ class MainActivity : ComponentActivity(), DIAware {
}
key(localeState) {
ProjectMeshTheme(appTheme = appTheme) {
- BottomNavApp(
- di,
- startDestination = currentScreen,
- onThemeChange = { selectedTheme -> appTheme = selectedTheme},
- onLanguageChange = { selectedLanguage -> languageCode = selectedLanguage},
- onNavigateToScreen = {screen ->
- currentScreen = screen },
- onRestartServer = {restartServerKey++},
- onDeviceNameChange = {deviceName = it},
- deviceName = deviceName,
- onAutoFinishChange = {autoFinish = it},
- onSaveToFolderChange = {saveToFolder = it}
- )
+ if (!hasRunBefore) {
+ OnboardingScreen(
+ onComplete = {meshPrefs.edit().putBoolean("hasRunBefore", true).apply()
+ hasRunBefore = true }
+ )
+ }
+ else{
+ BottomNavApp(
+ di,
+ startDestination = currentScreen,
+ onThemeChange = { selectedTheme -> appTheme = selectedTheme},
+ onLanguageChange = { selectedLanguage -> languageCode = selectedLanguage},
+ onNavigateToScreen = {screen ->
+ currentScreen = screen },
+ onRestartServer = {restartServerKey++},
+ onDeviceNameChange = {deviceName = it},
+ deviceName = deviceName,
+ onAutoFinishChange = {autoFinish = it},
+ onSaveToFolderChange = {saveToFolder = it}
+ )
+ }
}
}
}
+ Timber.tag("BuildCheck").d("Build Type is: ${BuildConfig.BUILD_TYPE}")
}
private fun ensureDefaultDirectory() {
@@ -140,14 +244,16 @@ class MainActivity : ComponentActivity(), DIAware {
if (!defaultDirectory.exists()) {
// Create the directory if it doesn't exist
if (defaultDirectory.mkdirs()) {
- Log.d("DirectoryCheck", "Default directory created: ${defaultDirectory.absolutePath}")
+ Timber.tag("DirectoryCheck").d("Default directory created: ${defaultDirectory
+ .absolutePath}")
}
else {
- Log.e("DirectoryCheck", "Failed to create default directory: ${defaultDirectory.absolutePath}")
+ Timber.tag("DirectoryCheck").e("Failed to create default directory: %s", defaultDirectory.absolutePath)
}
}
else {
- Log.d("DirectoryCheck", "Default directory already exists: ${defaultDirectory.absolutePath}")
+ Timber.tag("DirectoryCheck").d("Default directory already exists: ${defaultDirectory
+ .absolutePath}")
}
}
@@ -159,4 +265,409 @@ class MainActivity : ComponentActivity(), DIAware {
resources.updateConfiguration(config, resources.displayMetrics)
return locale
}
-}
\ No newline at end of file
+}
+
+@Composable
+fun BottomNavApp(di: DI,
+ startDestination: String,
+ onThemeChange: (AppTheme) -> Unit,
+ onLanguageChange: (String) -> Unit,
+ onNavigateToScreen: (String) -> Unit,
+ onRestartServer: () -> Unit,
+ onDeviceNameChange: (String) -> Unit,
+ deviceName: String,
+ onAutoFinishChange: (Boolean) -> Unit,
+ onSaveToFolderChange: (String) -> Unit
+) = withDI(di)
+{
+ val appServer: AppServer by di.instance()
+ val navController = rememberNavController()
+ // Observe the current route directly through the back stack entry
+ val currentRoute = navController.currentBackStackEntryFlow.collectAsState(initial = null)
+
+ LaunchedEffect(currentRoute.value?.destination?.route) {
+ if(currentRoute.value?.destination?.route == BottomNavItem.Settings.route){
+ currentRoute.value?.destination?.route?.let { route ->
+ onNavigateToScreen(route)
+ }
+ }
+ }
+
+ Scaffold(
+ bottomBar = { BottomNavigationBar(navController) }
+ ){ innerPadding ->
+ NavHost(navController, startDestination = startDestination, Modifier.padding(innerPadding))
+ {
+ composable(BottomNavItem.Home.route) { HomeScreen(deviceName = deviceName) }
+ composable(BottomNavItem.Network.route) {
+ // Just call NetworkScreen with no click callback
+ NetworkScreen(
+ onNodeClick = {ip -> navController.navigate("pingScreen/$ip")}
+ )
+ }
+ composable("chatScreen/{ip}"){ entry ->
+ val ip = entry.arguments?.getString("ip")
+ ?: throw IllegalArgumentException("Invalid address")
+
+ Timber.tag("Navigation").d("Navigating to chatScreen with parameter: $ip")
+
+ //determine if this is an ip address
+ val isValidIpAddress = ip.matches(Regex("^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\$"))
+ Timber.tag("Navigation").d("Is valid IP address: $isValidIpAddress")
+
+
+ if(isValidIpAddress) {
+ Timber.tag("Navigation").d("Showing chat for IP address: $ip")
+ // This is a valid IP address, use normal chat screen
+ ChatScreen(
+ virtualAddress = InetAddress.getByName(ip),
+ onClickButton = {
+ navController.navigate("pingScreen/${ip}")
+ }
+ )
+ } else {
+ Timber.tag("Navigation").d("Showing chat for conversation ID: $ip")
+ //conversation id: handle offline chat
+ ConversationChatScreen(
+ conversationId = ip,
+ onBackClick = {
+ Timber.tag("Navigation").d("Navigating back from conversation")
+ navController.popBackStack()
+ }
+ )
+ }
+ }
+
+ composable("pingScreen/{ip}"){ entry ->
+ val ip = entry.arguments?.getString("ip")
+ ?: throw IllegalArgumentException("Invalid address")
+ PingScreen(
+ virtualAddress = InetAddress.getByName(ip)
+ )
+ }
+
+ composable(BottomNavItem.Send.route) {
+ val activity = LocalContext.current as ComponentActivity
+ val sharedUrisViewModel: SharedUriViewModel = viewModel(activity)
+ SendScreen(
+ onSwitchToSelectDestNode = { uris ->
+ Timber.tag("uri_track_nav_send").d("size: %s", uris.size.toString())
+ Timber.tag("uri_track_nav_send").d("List: $uris")
+ sharedUrisViewModel.setUris(uris)
+ navController.navigate("selectDestNode")
+ }
+ )
+ }
+ composable("selectDestNode"){
+ val activity = LocalContext.current as ComponentActivity
+ val sharedUrisViewModel: SharedUriViewModel = viewModel(activity)
+ val sendUris by sharedUrisViewModel.uris.collectAsState()
+ Timber.tag("uri_track_nav_selectDestNode").d("size: %s", sendUris.size.toString())
+ Timber.tag("uri_track_nav_selectDestNode").d("List: $sendUris")
+ SelectDestNodeScreen(
+ uris = sendUris,
+ popBackWhenDone = {navController.popBackStack()},
+ )
+ }
+ composable(BottomNavItem.Receive.route) { ReceiveScreen(
+ onAutoFinishChange = onAutoFinishChange
+ ) }
+ composable(BottomNavItem.Log.route) {
+ LogScreen()
+ }
+ composable(BottomNavItem.Settings.route) {
+ // Retrieve required instances from DI with explicit types
+ val settingsPrefs: SharedPreferences by di.instance(tag = "settings")
+ val userRepository: UserRepository by di.instance()
+ SettingsScreen(
+ onThemeChange = onThemeChange,
+ onLanguageChange = onLanguageChange,
+ onRestartServer = onRestartServer,
+ onDeviceNameChange = { newDeviceName ->
+ Timber.tag("BottomNavApp").d("Device name changed to: $newDeviceName")
+ // Retrieve the local UUID from SharedPreferences
+ val localUuid = settingsPrefs.getString("UUID", null)
+ if (localUuid != null) {
+ // Update the local user info and broadcast in an IO coroutine
+ CoroutineScope(Dispatchers.IO).launch {
+ // 1. Update the local user in the database
+ userRepository.insertOrUpdateUser(
+ uuid = localUuid,
+ name = newDeviceName,
+ address = appServer.localVirtualAddr.hostAddress // <-- local IP here
+ )
+ Timber.tag("BottomNavApp").d("Updated local user with new name:$newDeviceName")
+
+ // 2. Retrieve all connected users (those with a non-null address)
+ val connectedUsers = userRepository.getAllConnectedUsers()
+ connectedUsers.forEach { user ->
+ user.address?.let { ip ->
+ try {
+ val remoteAddr = InetAddress.getByName(ip)
+ Timber.tag("BottomNavApp").d("Broadcasting updated info to: $ip")
+ appServer.pushUserInfoTo(remoteAddr)
+ } catch (e: Exception) {
+ Timber.tag("BottomNavApp").e(e, "Error processing IP " +
+ "address:$ip")
+ }
+ }
+ }
+ }
+ } else {
+ Timber.tag("BottomNavApp").e("Local UUID not found; cannot update user")
+ }
+ },
+ onAutoFinishChange = onAutoFinishChange,
+ onSaveToFolderChange = onSaveToFolderChange,
+ )
+ }
+ //I'm guessing I can put my Chat button here?
+ composable(BottomNavItem.Chat.route) {
+ //latest status of DeviceStatus manager
+ val deviceStatusRefreshTrigger = DeviceStatusManager.deviceStatusMap.collectAsState().value
+ // Show a list of nodes, let the user pick one
+ ConversationsHomeScreen(
+ onConversationSelected = { userIdentifier ->
+ // userIdentifier will be either an IP address (for online users)
+ // or a conversation ID (for offline users)
+ Timber.tag("Navigation").d("Selected conversation/user: $userIdentifier")
+ //navigate to the chat screen with this identifier
+ navController.navigate("chatScreen/${userIdentifier}")
+ }
+ )
+ /*
+ ChatNodeListScreen(
+ onNodeSelected = { ip ->
+ val remoteAddr = InetAddress.getByName(ip)
+ Timber.tag("ChatHandshake").d("Node selected with IP: $ip, remoteAddr:
+ $remoteAddr")
+
+ // Request remote user info
+ Timber.tag("ChatHandshake").d("Requesting remote user info from:
+ ${remoteAddr
+ .hostAddress}")
+ appServer.requestRemoteUserInfo(remoteAddr)
+
+ // Push local user info to remote node
+ Timber.tag("ChatHandshake").d("Pushing local user info to: ${remoteAddr
+ .hostAddress}")
+ appServer.pushUserInfoTo(remoteAddr)
+
+ // Navigate to the chat screen
+ navController.navigate("chatScreen/$ip")
+ }
+
+ )
+ */
+ }
+
+ //handle ip address chat screen properly
+ composable("chatScreen/{ip}"){ entry ->
+ val ipParam = entry.arguments?.getString("ip")
+ if (ipParam == null) {
+ // Handle missing parameter
+ Text("Error: Missing address parameter")
+ } else {
+ // Check if this is an IP address or conversation ID
+ val isValidIpAddress = ipParam.matches(Regex("^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\$"))
+
+ val validatedAddress = remember(ipParam) {
+ if (isValidIpAddress) {
+ try {
+ InetAddress.getByName(ipParam)
+ } catch (e: Exception) {
+ Timber.tag("Navigation").e(e, "Error creating address from parameter:$ipParam")
+ null
+ }
+ } else {
+ null
+ }
+ }
+ if (isValidIpAddress && validatedAddress != null) {
+ // It's a valid IP address
+ ChatScreen(
+ virtualAddress = validatedAddress,
+ onClickButton = {
+ navController.navigate("pingScreen/${ipParam}")
+ }
+ )
+ } else {
+ // Handle as conversation ID
+ ConversationChatScreen(
+ conversationId = ipParam,
+ onBackClick = {
+ navController.popBackStack()
+ }
+ )
+ }
+ }
+ }
+ }
+ }
+}
+
+
+@Composable
+fun ConversationChatScreen (
+ conversationId: String,
+ onBackClick: () -> Unit
+){
+ Timber.tag("ConversationChatScreen").d("Starting to load conversation: $conversationId")
+
+ var conversationState = remember { mutableStateOf(null) }
+ var isLoading = remember { mutableStateOf(true) }
+ var errorMessage = remember { mutableStateOf(null) }
+ //val conversation = conversationState.value
+ val context = LocalContext.current
+
+ val coroutineScope = rememberCoroutineScope()
+
+ // Load the conversation data
+ LaunchedEffect(conversationId) {
+ Timber.tag("ConversationChatScreen").d("LaunchedEffect triggered for ID: $conversationId")
+ coroutineScope.launch {
+ try {
+ Timber.tag("ConversationChatScreen").d("Attempting to fetch conversation")
+ val result = GlobalApp.GlobalUserRepo.conversationRepository.getConversationById(conversationId)
+ Timber.tag("ConversationChatScreen").d("Fetch result: ${result != null}")
+ //conversationState.value = result
+
+ if (result == null) {
+ errorMessage.value = "Conversation not found"
+ isLoading.value = false
+ /*
+ Timber.tag("ConversationChatScreen").e("Conversation not found:
+ $conversationId")
+ Toast.makeText(
+ context,
+ "Conversation not found",
+ Toast.LENGTH_SHORT
+ ).show()
+ onBackClick()
+ */
+ }else {
+ conversationState.value = result
+ isLoading.value = false
+ Timber.tag("ConversationChatScreen").d("Loaded conversation: ${result.userName}, online=${result.isOnline}")
+ }
+ } catch (e: Exception) {
+ Timber.tag("ConversationChatScreen").e(e, "Error loading conversation")
+ errorMessage.value = e.message
+ isLoading.value = false
+ /*
+ Toast.makeText(
+ context,
+ "Error loading conversation: ${e.message}",
+ Toast.LENGTH_SHORT
+ ).show()
+ onBackClick()
+ */
+ }
+ }
+ }
+
+ // Show loading state while fetching conversation
+ if (isLoading.value) {
+ Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+ CircularProgressIndicator()
+ }
+ return
+ }
+
+ //show error if loading failed
+ if (errorMessage.value != null) {
+ Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+ Column(horizontalAlignment = Alignment.CenterHorizontally) {
+ Text("Error: ${errorMessage.value}")
+ Button(onClick = onBackClick) {
+ Text("Go Back")
+ }
+ }
+ }
+ return
+ }
+
+ //get the conversation from state
+ val conversation = conversationState.value
+ if (conversation == null) {
+ Toast.makeText(context, "Conversation not found", Toast.LENGTH_SHORT).show()
+ onBackClick()
+ return
+ }
+
+ val shouldCheckDeviceStatus = remember {
+ // Only check for devices with real IP addresses, not placeholder or offline devices
+ conversation.userAddress != null &&
+ conversation.userAddress != "0.0.0.0" &&
+ conversation.userAddress != TestDeviceService.TEST_DEVICE_IP_OFFLINE
+ }
+
+ // Initialize isUserOnline based on conversation state first
+ var isUserOnline by remember { mutableStateOf(conversation.isOnline) }
+
+ // If we should check device status, observe DeviceStatusManager
+ if (shouldCheckDeviceStatus) {
+ val deviceStatusMap by DeviceStatusManager.deviceStatusMap.collectAsState()
+ // Update isUserOnline based on DeviceStatusManager
+ LaunchedEffect(deviceStatusMap) {
+ conversation.userAddress?.let { ipAddress ->
+ val statusFromManager = deviceStatusMap[ipAddress] ?: false
+ if (isUserOnline != statusFromManager) {
+ Timber.tag("ConversationChatScreen").d("Device status changed for ${conversation
+ .userName}: ${if (statusFromManager) "online" else "offline"}")
+ isUserOnline = statusFromManager
+ }
+ }
+ }
+ }
+
+ // Create a virtual address based on the conversation data
+ val virtualAddress = if (conversation?.userAddress.isNullOrEmpty()) {
+ //use offline test device address if this is the offline test conversation
+ if (conversation.userName == TestDeviceService.TEST_DEVICE_NAME_OFFLINE) {
+ Timber.tag("ConversationChatScreen").d("Using offline test device address")
+ InetAddress.getByName(TestDeviceService.TEST_DEVICE_IP_OFFLINE)
+ } else {
+ //use a placeholder address for regular offline users
+ Timber.tag("ConversationChatScreen").d("Using placeholder address for offline user")
+ InetAddress.getByName("0.0.0.0")
+ }
+ } else {
+ //use the actual address if available
+ Timber.tag("ConversationChatScreen").d("Using actual address: ${conversation.userAddress}")
+ InetAddress.getByName(conversation.userAddress)
+ }
+
+ Timber.tag("ConversationChatScreen").d("Showing chat screen for: ${conversation.userName}")
+
+ // Show the chat screen
+ ChatScreen(
+ virtualAddress = virtualAddress,
+ userName = conversation.userName,
+ isOffline = !conversation.isOnline,
+ onClickButton = {
+ // Disable ping for offline users
+ Toast.makeText(
+ context,
+ "Cannot ping offline users",
+ Toast.LENGTH_SHORT
+ ).show()
+ },
+ viewModel = viewModel(
+ factory = ViewModelFactory(
+ di = localDI(),
+ owner = LocalSavedStateRegistryOwner.current,
+ vmFactory = { di, savedStateHandle ->
+ // Make sure to set the conversation ID in the savedStateHandle
+ savedStateHandle["conversationId"] = conversationId
+ ChatScreenViewModel(di, savedStateHandle)
+ },
+ defaultArgs = Bundle().apply {
+ putSerializable("virtualAddress", virtualAddress)
+ putString("conversationId", conversationId)
+ }
+ )
+ )
+ )
+}
+
diff --git a/app/src/main/java/com/greybox/projectmesh/components/WifiConnection.kt b/app/src/main/java/com/greybox/projectmesh/components/WifiConnection.kt
index f56ca51e..e3ab6ca3 100644
--- a/app/src/main/java/com/greybox/projectmesh/components/WifiConnection.kt
+++ b/app/src/main/java/com/greybox/projectmesh/components/WifiConnection.kt
@@ -20,12 +20,13 @@ import androidx.compose.runtime.setValue
import androidx.compose.runtime.getValue
import androidx.compose.ui.platform.LocalContext
import com.greybox.projectmesh.extension.NEARBY_WIFI_PERMISSION_NAME
+import com.ustadmobile.meshrabiya.log.MNetLogger
import com.ustadmobile.meshrabiya.vnet.AndroidVirtualNode
import com.ustadmobile.meshrabiya.vnet.wifi.ConnectBand
import com.ustadmobile.meshrabiya.vnet.wifi.HotspotType
import com.ustadmobile.meshrabiya.vnet.wifi.WifiConnectException
import java.util.regex.Pattern
-
+import android.util.Log
// This File is to pre-check the wifi connection, reusing from Meshrabiya test app
/*
@@ -60,6 +61,7 @@ enum class ConnectWifiLauncherStatus {
@Composable
fun meshrabiyaConnectLauncher(
node: AndroidVirtualNode,
+ logger: MNetLogger? = null,
onStatusChange: ((ConnectWifiLauncherStatus) -> Unit)?= null,
onResult: (ConnectWifiLauncherResult) -> Unit,
): ConnectWifiLauncher {
@@ -75,7 +77,7 @@ fun meshrabiyaConnectLauncher(
val deviceManager: CompanionDeviceManager =
context.getSystemService(Context.COMPANION_DEVICE_SERVICE) as CompanionDeviceManager
val associations = deviceManager.associations
- // logger?.invoke(Log.INFO, "associations = ${associations.joinToString()}")
+ logger?.invoke(Log.INFO, "associations = ${associations.joinToString()}")
val request = pendingAssociationRequest ?: return@rememberLauncherForActivityResult
pendingAssociationRequest = null
@@ -85,7 +87,7 @@ fun meshrabiyaConnectLauncher(
CompanionDeviceManager.EXTRA_DEVICE
)
- //logger?.invoke(Log.INFO, "rememberConnectWifiLauncher: Got scan result: bssid = ${scanResult?.BSSID}")
+ logger?.invoke(Log.INFO, "rememberConnectWifiLauncher: Got scan result: bssid = ${scanResult?.BSSID}")
node.storeBssid(request.connectConfig.ssid, scanResult?.BSSID)
onResult(
@@ -112,7 +114,7 @@ fun meshrabiyaConnectLauncher(
val connectRequestVal = pendingPermissionRequest ?: return@rememberLauncherForActivityResult
pendingPermissionRequest = null
if(granted) {
- // logger?.invoke(Log.DEBUG, "ConnectWifiLauncher: permission granted")
+ logger?.invoke(Log.DEBUG, "ConnectWifiLauncher: permission granted")
pendingAssociationRequest = connectRequestVal
}else {
onResult(
@@ -137,7 +139,7 @@ fun meshrabiyaConnectLauncher(
context.getSystemService(Context.COMPANION_DEVICE_SERVICE) as CompanionDeviceManager
if(knownBssid != null) {
- // logger?.invoke(Log.DEBUG, "ConnectWifiLauncher: already associated with $ssid (bssid=$knownBssid)")
+ logger?.invoke(Log.DEBUG, "ConnectWifiLauncher: already associated with $ssid (bssid=$knownBssid)")
onStatusChange?.invoke(ConnectWifiLauncherStatus.INACTIVE)
onResult(
ConnectWifiLauncherResult(
@@ -148,9 +150,9 @@ fun meshrabiyaConnectLauncher(
)
)
}else {
- // logger?.invoke(Log.DEBUG,
- // "ConnectWifiLauncher: requesting association for $ssid"
- // )
+ logger?.invoke(Log.DEBUG,
+ "ConnectWifiLauncher: requesting association for $ssid"
+ )
onStatusChange?.invoke(ConnectWifiLauncherStatus.LOOKING_FOR_NETWORK)
val deviceFilter = WifiDeviceFilter.Builder()
.setNamePattern(Pattern.compile(Pattern.quote(connectRequestVal.connectConfig.ssid)))
@@ -167,7 +169,7 @@ fun meshrabiyaConnectLauncher(
object: CompanionDeviceManager.Callback() {
@Deprecated("Deprecated in Java")
override fun onDeviceFound(intentSender: IntentSender) {
- // logger?.invoke(Log.DEBUG, "ConnectWifiLauncher: onDeviceFound for $ssid")
+ logger?.invoke(Log.DEBUG, "ConnectWifiLauncher: onDeviceFound for $ssid")
onStatusChange?.invoke(ConnectWifiLauncherStatus.REQUESTING_LINK)
intentSenderLauncher.launch(
IntentSenderRequest.Builder(intentSender).build()
@@ -175,7 +177,7 @@ fun meshrabiyaConnectLauncher(
}
override fun onFailure(reason: CharSequence?) {
- // logger?.invoke(Log.DEBUG, "ConnectWifiLauncher: onFailure for $ssid - $reason")
+ logger?.invoke(Log.DEBUG, "ConnectWifiLauncher: onFailure for $ssid - $reason")
onStatusChange?.invoke(ConnectWifiLauncherStatus.INACTIVE)
pendingAssociationRequest = null
onResult(
diff --git a/app/src/main/java/com/greybox/projectmesh/db/MeshDatabase.kt b/app/src/main/java/com/greybox/projectmesh/db/MeshDatabase.kt
index 02b31b70..1f3dba4c 100644
--- a/app/src/main/java/com/greybox/projectmesh/db/MeshDatabase.kt
+++ b/app/src/main/java/com/greybox/projectmesh/db/MeshDatabase.kt
@@ -2,10 +2,24 @@ package com.greybox.projectmesh.db
import androidx.room.Database
import androidx.room.RoomDatabase
-import com.greybox.projectmesh.db.dao.MessageDao
-import com.greybox.projectmesh.db.entities.Message
+import com.greybox.projectmesh.messaging.data.dao.MessageDao
+import com.greybox.projectmesh.messaging.data.dao.ConversationDao
+import com.greybox.projectmesh.messaging.data.entities.Message
+import com.greybox.projectmesh.messaging.data.entities.Conversation
+import com.greybox.projectmesh.user.UserDao
+import com.greybox.projectmesh.user.UserEntity
-@Database(entities = [Message::class], version = 2)
+@Database(
+ entities = [
+ Message::class,
+ UserEntity::class, // <- add this
+ Conversation::class
+ ],
+ version = 4,
+ exportSchema = false
+)
abstract class MeshDatabase : RoomDatabase() {
abstract fun messageDao(): MessageDao
-}
\ No newline at end of file
+ abstract fun userDao(): UserDao
+ abstract fun conversationDao(): ConversationDao
+}
diff --git a/app/src/main/java/com/greybox/projectmesh/db/entities/Message.kt b/app/src/main/java/com/greybox/projectmesh/db/entities/Message.kt
deleted file mode 100644
index 00fc45d9..00000000
--- a/app/src/main/java/com/greybox/projectmesh/db/entities/Message.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-package com.greybox.projectmesh.db.entities
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-
-@Entity(tableName = "message")
-data class Message(
- @PrimaryKey(autoGenerate = true) val id: Int,
- @ColumnInfo(name = "dateReceived") val dateReceived: Long,
- @ColumnInfo(name = "content") val content: String,
- @ColumnInfo(name = "sender") val sender: String,
- @ColumnInfo(name = "chat") val chat: String
-)
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/debug/CrashHandler.kt b/app/src/main/java/com/greybox/projectmesh/debug/CrashHandler.kt
index 3cc15d6a..684faa5c 100644
--- a/app/src/main/java/com/greybox/projectmesh/debug/CrashHandler.kt
+++ b/app/src/main/java/com/greybox/projectmesh/debug/CrashHandler.kt
@@ -1,13 +1,9 @@
package com.greybox.projectmesh.debug
-import android.R.layout
import android.content.Context
import android.content.Intent
-import android.util.Log
-import android.widget.FrameLayout
-import android.widget.PopupWindow
import com.google.gson.Gson
-import org.xml.sax.helpers.DefaultHandler
+import timber.log.Timber
import java.lang.Exception
import java.lang.Thread.UncaughtExceptionHandler
import kotlin.system.exitProcess
@@ -29,7 +25,7 @@ class CrashHandler(private val context: Context, private val defaultHandler: Unc
{
val crashIntent = Intent(applicationContext, activity).also {
it.putExtra("CrashData", Gson().toJson(exception))
- Log.e("Project Mesh Error","Error: ",exception);
+ Timber.tag("Project Mesh Error").e(exception, "Error: ");
}
crashIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_NEW_TASK)
@@ -50,7 +46,7 @@ class CrashHandler(private val context: Context, private val defaultHandler: Unc
Gson().fromJson(intent.getStringExtra("CrashData"), Throwable::class.java)
}
catch (e: Exception) {
- Log.e("CrashHandler","getThrowableFromIntent: ",e);
+ Timber.tag("CrashHandler",).e(e,"getThrowableFromIntent: ");
null
}
diff --git a/app/src/main/java/com/greybox/projectmesh/extension/ContextExt.kt b/app/src/main/java/com/greybox/projectmesh/extension/ContextExt.kt
index 3ceb6201..c2cfa463 100644
--- a/app/src/main/java/com/greybox/projectmesh/extension/ContextExt.kt
+++ b/app/src/main/java/com/greybox/projectmesh/extension/ContextExt.kt
@@ -9,6 +9,7 @@ import androidx.core.content.ContextCompat
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.preferencesDataStore
+import com.ustadmobile.meshrabiya.MeshrabiyaConstants
/*
context is a class that provides access to application-specific resources and classes.
@@ -49,4 +50,23 @@ val Context.networkDataStore: DataStore by preferencesDataStore(nam
// Check if the device supports WiFi STA/AP Concurrency
fun Context.hasStaApConcurrency(): Boolean {
return Build.VERSION.SDK_INT >= 30 && getSystemService(WifiManager::class.java).isStaApConcurrencySupported
+}
+
+fun Context.deviceInfo(): String {
+ val wifiManager = getSystemService(WifiManager::class.java)
+ val hasStaConcurrency = Build.VERSION.SDK_INT >= 31 &&
+ wifiManager.isStaConcurrencyForLocalOnlyConnectionsSupported
+ val hasStaApConcurrency = Build.VERSION.SDK_INT >= 30 &&
+ wifiManager.isStaApConcurrencySupported
+ val hasWifiAwareSupport = packageManager.hasSystemFeature(PackageManager.FEATURE_WIFI_AWARE)
+
+ return buildString {
+ append("Meshrabiya: Version :${MeshrabiyaConstants.VERSION}\n")
+ append("Android Version: ${Build.VERSION.RELEASE} (SDK ${Build.VERSION.SDK_INT})\n")
+ append("Device: ${Build.MANUFACTURER} - ${Build.MODEL}\n")
+ append("5Ghz supported: ${wifiManager.is5GHzBandSupported}\n")
+ append("Local-only station concurrency: $hasStaConcurrency\n")
+ append("Station-AP concurrency: $hasStaApConcurrency\n")
+ append("WifiAware support: $hasWifiAwareSupport\n")
+ }
}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/extension/NetworkUtils.kt b/app/src/main/java/com/greybox/projectmesh/extension/NetworkUtils.kt
new file mode 100644
index 00000000..d9b8ae0e
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/extension/NetworkUtils.kt
@@ -0,0 +1,11 @@
+package com.greybox.projectmesh.extension
+
+import com.ustadmobile.meshrabiya.vnet.AndroidVirtualNode
+import org.kodein.di.DI
+import org.kodein.di.instance
+
+fun getLocalIpFromDI(di: DI): String {
+ // Retrieve the AndroidVirtualNode from DI and return its IP address
+ val node: AndroidVirtualNode by di.instance()
+ return node.address.hostAddress
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/extension/WifiListItem.kt b/app/src/main/java/com/greybox/projectmesh/extension/WifiListItem.kt
new file mode 100644
index 00000000..d8992dfc
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/extension/WifiListItem.kt
@@ -0,0 +1,92 @@
+package com.greybox.projectmesh.extension
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Image
+import androidx.compose.material.icons.filled.SignalCellular4Bar
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import com.greybox.projectmesh.GlobalApp
+import com.ustadmobile.meshrabiya.ext.addressToDotNotation
+import com.ustadmobile.meshrabiya.vnet.VirtualNode
+import kotlinx.coroutines.runBlocking
+import com.greybox.projectmesh.user.UserRepository
+@Composable
+// Display a single connected wifi station
+fun WifiListItem(
+ wifiAddress: Int,
+ wifiEntry: VirtualNode.LastOriginatorMessage,
+ onClick: ((nodeAddress: String) -> Unit)? = null,
+){
+ val wifiAddressDotNotation = wifiAddress.addressToDotNotation()
+ ListItem(
+ modifier = Modifier.fillMaxWidth().let{
+ if(onClick != null){
+ it.clickable(onClick = {
+ onClick(wifiAddressDotNotation)
+ })
+ }
+ else{
+ it
+ }
+ },
+ leadingContent = {
+ // The image icon on the left side
+ Icon(
+ // replace this image with a custom icon or image
+ imageVector = Icons.Default.Image,
+ contentDescription = "Profile Picture",
+ modifier = Modifier.size(28.dp)
+ )
+ },
+ headlineContent = {
+ // obtain the device name according to the ip address
+ val user = runBlocking {
+ GlobalApp.GlobalUserRepo.userRepository.getUserByIp(wifiAddressDotNotation)
+ }
+ val device = user?.name ?: "Unknown"
+ if(device != null){
+ Text(text= device, fontWeight = FontWeight.Bold)
+ }
+ else{
+ Text(text = "Loading...", fontWeight = FontWeight.Bold)
+ }
+ },
+ supportingContent = {
+ Text(text = wifiAddressDotNotation)
+ },
+ trailingContent = {
+ // The mesh status with signal bars and text
+ Row(
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ Icon(
+ imageVector = Icons.Default.SignalCellular4Bar,
+ contentDescription = "Mesh Signal Strength",
+ modifier = Modifier.size(24.dp)
+ )
+ Spacer(modifier = Modifier.width(4.dp))
+ Column{
+ Text(text = "Mesh status")
+ Spacer(modifier = Modifier.width(4.dp))
+ Text("Ping: ${wifiEntry.originatorMessage.pingTimeSum}ms "
+ + "Hops: ${wifiEntry.hopCount} ")
+ }
+ }
+ }
+ )
+ HorizontalDivider()
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/logging/ReleaseTree.kt b/app/src/main/java/com/greybox/projectmesh/logging/ReleaseTree.kt
new file mode 100644
index 00000000..7bb25e13
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/logging/ReleaseTree.kt
@@ -0,0 +1,20 @@
+package com.greybox.projectmesh.logging
+
+import android.util.Log
+import timber.log.Timber
+
+class ReleaseTree : Timber.Tree() {
+ @Suppress("LogNotTimber")
+ override fun log(priority: Int, tag: String?, message: String, t: Throwable?) {
+ // Log WARN and ERROR only to avoid leaking debug info in release
+ if (priority == Log.ERROR || priority == Log.WARN) {
+ val safeTag = tag ?: "ReleaseTree"
+ Log.println(priority, safeTag, message)
+
+ // Log Exceptions if present
+ t?.let {
+ Log.e(safeTag, "Exception: $message", it)
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/README.md b/app/src/main/java/com/greybox/projectmesh/messaging/README.md
new file mode 100644
index 00000000..120b26d9
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/README.md
@@ -0,0 +1,288 @@
+# Messaging Module Documentation
+
+## Overview
+The messaging module is a core component of Project Mesh that enables peer-to-peer text communications between devices on the local mesh network. It provides a structured architecture for sending, receiving, storing, and displaying messages without requiring internet connectivity.
+
+## Package Structure
+```
+messaging/
+├── data/ # Data layer (entities and DAOs)
+│ ├── dao/ # Database Access Objects
+│ └── entities/ # Data models (Message, Conversation)
+├── network/ # Network communication handlers
+├── repository/ # Business logic and data management
+└── ui/ # User interface components
+├── models/ # UI state models
+├── screens/ # Composable UI screens
+└── viewmodels/# View state management
+```
+## Core Components
+
+### 1. Data Models
+#### Message Entity
+```Kotlin
+@Serializable
+@Entity(tableName = "message")
+data class Message(
+ @PrimaryKey(autoGenerate = true) val id: Int,
+ @ColumnInfo(name = "dateReceived") val dateReceived: Long,
+ @ColumnInfo(name = "content") val content: String,
+ @ColumnInfo(name = "sender") val sender: String,
+ @ColumnInfo(name = "chat") val chat: String,
+ @ColumnInfo(name= "file") val file: URI? = null
+)
+```
+#### Conversation Entity
+```Kotlin
+@Entity(tableName = "conversations")
+data class Conversation(
+ @PrimaryKey val id: String, // Composite ID of the two users
+ @ColumnInfo(name = "user_uuid") val userUuid: String, // Other user ID
+ @ColumnInfo(name = "user_name") val userName: String, // Other user name
+ @ColumnInfo(name = "user_address") val userAddress: String?, // Other user IP address
+ @ColumnInfo(name = "last_message") val lastMessage: String?, // Last message text
+ @ColumnInfo(name = "last_message_time") val lastMessageTime: Long, // Timestamp
+ @ColumnInfo(name = "unread_count") val unreadCount: Int = 0, // Unread count
+ @ColumnInfo(name = "is_online") val isOnline: Boolean = false // Online status
+)
+```
+### 2. Repositories
+#### MessageRepository
+Manages message data operations, including retrieving and storing messages.
+#### ConversationRepository
+Manages conversation data, including creating and updating conversations, tracking user statuses, and managing unread messages.
+### 3. Network Components
+#### MessageNetworkHandler
+ Handles network communication for sending and receiving messages using HTTP requests.
+### 4. UI Components
+#### ChatScreen
+ Displays messages in a conversation and provides UI controls for sending new messages.
+#### ConversationsHomeScreen
+ Displays a list of all conversations with status indicators and message previews.
+
+## Architecture and Data Flow
+### Message Flow
+
+#### 1. User Sends Message:
+* User enters text in ChatScreen and taps Send
+* ChatScreenViewModel processes the input
+* Message is first saved locally in the database
+* MessageNetworkHandler sends the message to recipient via HTTP
+#### 2. Message Reception:
+* AppServer receives HTTP request on /chat endpoint
+* MessageNetworkHandler processes the incoming message
+* Message is stored in local database
+* ConversationRepository updates the conversation
+* UI is updated via StateFlow collection
+
+### Integration with Project Mesh Components
+#### Network Integration
+Messages are transmitted over the mesh network created by the Meshrabiya library. The system uses:
+
+1. `AppServer`: Provides HTTP endpoints for receiving messages and handles file transfers.
+2. `DeviceStatusManager`: Tracks online/offline status of devices to determine message deliverability.
+3. `AndroidVirtualNode`: Manages the underlying mesh network connections.
+
+```kotlin
+// In AppServer.kt
+// Handles incoming chat messages
+else if(path.startsWith("/chat")) {
+ // Process JSON payload
+ val chatMessage = deserialzedJSON.content
+ val time = deserialzedJSON.dateReceived
+ val senderIp = deserialzedJSON.sender
+
+ // Handle message via MessageNetworkHandler
+ val message = MessageNetworkHandler.handleIncomingMessage(
+ chatMessage, time, senderIp, incomingfile
+ )
+
+ // Save to database
+ db.messageDao().addMessage(message)
+}
+```
+
+#### User System Integration
+Messages and conversations are linked to user profiles:
+1. Each message contains a sender field with the username
+2. Conversations use a composite ID created from the UUIDs of both participants
+3. Online status is synchronized with the DeviceStatusManager
+
+```kotlin
+// In ConversationUtils.kt
+fun createConversationId(uuid1: String, uuid2: String): String {
+ // Sort UUIDs to ensure consistent IDs regardless of sender/receiver
+ return listOf(uuid1, uuid2).sorted().joinToString("-")
+}
+```
+
+#### Database Integration
+The messaging module uses Room database for persistence:
+1. **MeshDatabase**: Central database that contains tables for:
+* `messages`: Stores all message content
+* `conversations`: Stores conversation metadata
+* `users`: Stores user profile information
+2. Relationship Flow:
+* Users have multiple Conversations
+* Conversations contain multiple Messages
+* Messages reference their Conversation via the chat field
+```kotlin
+// In MeshDatabase.kt
+@Database(
+ entities = [
+ Message::class,
+ UserEntity::class,
+ Conversation::class
+ ],
+ version = 4,
+ exportSchema = false
+)
+abstract class MeshDatabase : RoomDatabase() {
+ abstract fun messageDao(): MessageDao
+ abstract fun userDao(): UserDao
+ abstract fun conversationDao(): ConversationDao
+}
+```
+## Special Features
+### Offline Messaging
+1. Messages are always stored locally first
+2. If recipient is offline, message remains in local database
+3. UI indicates delivery status based on device connectivity
+4. Messages appear in conversation history regardless of delivery status
+### Test Device Integration
+Special handling for test devices that simulate real users:
+* Online test device automatically responds with echo messages
+* Offline test device stores messages locally but never receives them
+
+### File Attachments
+1. Messages can include file URI attachments
+2. Files are transferred separately using the file transfer system
+3. Messages with attachments display file indicators in the UI
+### Usage Example
+
+#### Conversations Screen:
+
+
+
+* Online and Offline Users Appear With Appropriate Read Receipts from Built-in Sample Messages
+* Connected device appears in the Conversation Screen
+
+#### Chat Screen Initial Impressions
+
+
+
+* When chatting for the first time a prompt appears to start a chat
+
+#### Sending A Message
+
+**Example**: Bob sends Message to Alice
+
+
+
+```kotlin
+// In ChatScreenViewModel.kt
+fun sendChatMessage(virtualAddress: InetAddress, message: String, file: URI?) {
+ val sendTime = System.currentTimeMillis()
+ val isOnline = DeviceStatusManager.isDeviceOnline(ipAddress)
+
+ // Create message entity
+ val messageEntity = Message(
+ id = 0,
+ dateReceived = sendTime,
+ content = message,
+ sender = "Me",
+ chat = chatName,
+ file = file
+ )
+
+ viewModelScope.launch {
+ // Save to local database
+ db.messageDao().addMessage(messageEntity)
+
+ // Update conversation
+ conversationRepository.updateWithMessage(
+ conversationId = conversation.id,
+ message = messageEntity
+ )
+
+ // Send message if recipient is online
+ if (isOnline) {
+ appServer.sendChatMessageWithStatus(
+ virtualAddress, sendTime, message, file
+ )
+ }
+ }
+}
+```
+#### Receiving and Displaying Messages
+
+**Example**: Bob Recieves Message From Alice
+
+1. Conversation is Updated and Read Receipt is shown:
+
+
+
+2. Bob can View the message in the Chat Screen
+
+
+
+3. When Going back to the Chat Screen Read Status is Updated:
+
+
+
+```kotlin
+// In ChatScreenViewModel.kt
+init {
+ viewModelScope.launch {
+ // Observe message database for this conversation
+ db.messageDao().getChatMessagesFlow(chatName).collect { newChatMessages ->
+ _uiState.update { prev ->
+ prev.copy(allChatMessages = newChatMessages)
+ }
+ }
+ }
+}
+```
+## Best Practices
+### 1. Consider Network Conditions:
+* Always check device online status before sending
+* Provide clear UI feedback for undelivered messages
+* Handle intermittent connectivity gracefully
+
+### 2. Database Operations:
+* Perform all database operations on IO dispatchers
+* Use Room's Flow API for reactive UI updates
+* Keep transactions atomic to prevent data corruption
+
+### 3. User Experience:
+* Show clear online/offline indicators
+* Provide delivery status for messages
+* Update conversation timestamps and previews promptly
+
+### 4. Security Considerations:
+* Validate message content before processing
+* Use proper JSON schema validation for incoming messages
+* Sanitize user input to prevent injection attacks
+
+## Troubleshooting
+### Common Issues
+#### 1. Messages Not Sending:
+* Check device status in DeviceStatusManager
+* Verify network connectivity between devices
+* Confirm AppServer is running on both devices
+
+#### 2. Missing Conversations:
+* Ensure user profile exchange was successful
+* Check conversation ID generation is consistent
+* Verify database migrations have completed
+
+#### 3. UI Not Updating:
+* Confirm StateFlow collection is active
+* Check database queries are properly observed
+* Verify Composable recomposition triggers
+
+## Future Enhancements
+1. **Message Encryption**: Add end-to-end encryption for message content
+2. **Message Status**: Add read receipts and delivery confirmations
+3. **Rich Media**: Enhance support for images, videos, and other media types
+4. **Group Messaging**: Extend the system to support multi-user conversations
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/data/dao/ConversationDao.kt b/app/src/main/java/com/greybox/projectmesh/messaging/data/dao/ConversationDao.kt
new file mode 100644
index 00000000..8e143936
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/data/dao/ConversationDao.kt
@@ -0,0 +1,39 @@
+package com.greybox.projectmesh.messaging.data.dao
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import androidx.room.Update
+import com.greybox.projectmesh.messaging.data.entities.Conversation
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface ConversationDao {
+ @Query("SELECT * FROM conversations ORDER BY last_message_time DESC")
+ fun getAllConversationsFlow(): Flow>
+
+ @Query("SELECT * FROM conversations WHERE id = :conversationId LIMIT 1")
+ suspend fun getConversationById(conversationId: String): Conversation?
+
+ @Query("SELECT * FROM conversations WHERE user_uuid = :userUuid LIMIT 1")
+ suspend fun getConversationByUserUuid(userUuid: String): Conversation?
+
+ @Insert(onConflict = OnConflictStrategy.REPLACE)
+ suspend fun insertConversation(conversation: Conversation)
+
+ @Update
+ suspend fun updateConversation(conversation: Conversation)
+
+ @Query("UPDATE conversations SET is_online = :isOnline, user_address = :userAddress WHERE user_uuid = :userUuid")
+ suspend fun updateUserConnectionStatus(userUuid: String, isOnline: Boolean, userAddress: String?)
+
+ @Query("UPDATE conversations SET last_message = :lastMessage, last_message_time = :timestamp WHERE id = :conversationId")
+ suspend fun updateLastMessage(conversationId: String, lastMessage: String, timestamp: Long)
+
+ @Query("UPDATE conversations SET unread_count = unread_count + 1 WHERE id = :conversationId")
+ suspend fun incrementUnreadCount(conversationId: String)
+
+ @Query("UPDATE conversations SET unread_count = 0 WHERE id = :conversationId")
+ suspend fun clearUnreadCount(conversationId: String)
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/db/dao/MessageDao.kt b/app/src/main/java/com/greybox/projectmesh/messaging/data/dao/MessageDao.kt
similarity index 58%
rename from app/src/main/java/com/greybox/projectmesh/db/dao/MessageDao.kt
rename to app/src/main/java/com/greybox/projectmesh/messaging/data/dao/MessageDao.kt
index 7da5bef5..7afe14e0 100644
--- a/app/src/main/java/com/greybox/projectmesh/db/dao/MessageDao.kt
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/data/dao/MessageDao.kt
@@ -1,10 +1,10 @@
-package com.greybox.projectmesh.db.dao
+package com.greybox.projectmesh.messaging.data.dao
import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.Query
-import com.greybox.projectmesh.db.entities.Message
+import com.greybox.projectmesh.messaging.data.entities.Message
import kotlinx.coroutines.flow.Flow
@Dao
@@ -21,6 +21,13 @@ interface MessageDao {
@Query("DELETE FROM message")
fun clearTable()
+ @Query("SELECT * FROM message WHERE chat IN (:chatNames) ORDER BY dateReceived ASC")
+ fun getChatMessagesFlowMultipleNames(chatNames: List): Flow>
+
+ //Synchronously Query to get messages immediately
+ @Query("SELECT * FROM message WHERE chat = :chat ORDER BY dateReceived ASC")
+ fun getChatMessagesSync(chat: String): List
+
@Insert
suspend fun addMessage(m: Message)
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/Conversation.kt b/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/Conversation.kt
new file mode 100644
index 00000000..aca71676
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/Conversation.kt
@@ -0,0 +1,21 @@
+package com.greybox.projectmesh.messaging.data.entities
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import java.util.UUID
+
+//Conversation Entity, representing a chat thread with another user
+
+@Entity(tableName = "conversations")
+data class Conversation(
+ @PrimaryKey val id: String, //Composite id of the two users
+ @ColumnInfo(name = "user_uuid") val userUuid: String, //other user id
+ @ColumnInfo(name = "user_name") val userName: String, //other user name
+ @ColumnInfo(name = "user_address") val userAddress: String?, // other user ip address
+ @ColumnInfo(name = "last_message") val lastMessage: String?, //last message text
+ @ColumnInfo(name = "last_message_time") val lastMessageTime: Long, //Timestamp of last message
+ @ColumnInfo(name = "unread_count") val unreadCount: Int = 0, //count of unread messages
+ @ColumnInfo(name = "is_online") val isOnline: Boolean = false //whether the user is online
+
+)
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/FileEncoder.kt b/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/FileEncoder.kt
new file mode 100644
index 00000000..6fd45f97
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/FileEncoder.kt
@@ -0,0 +1,79 @@
+package com.greybox.projectmesh.messaging.data.entities
+
+import android.content.Context
+import android.net.Uri
+import java.io.File
+import java.io.FileOutputStream
+import java.io.InputStream
+import kotlin.io.encoding.Base64
+import kotlin.io.encoding.ExperimentalEncodingApi
+import java.net.InetAddress
+import java.net.URLEncoder
+import java.net.HttpURLConnection
+import java.net.URL
+
+//Use this to encode files not just images
+//Needs to be tested sometime
+//Can I modify this so that Http transfer does the majority of the encoding?
+class FileEncoder {//Made by Craig. Encodes via base64.
+
+ @OptIn(ExperimentalEncodingApi::class)
+ fun encodebase64(ctxt: Context, inputuri: Uri): String?{
+ try {
+ val encodedstrm: InputStream? = ctxt.contentResolver.openInputStream(inputuri)
+ val bytes = encodedstrm?.readBytes()
+ encodedstrm?.close()
+ return if (bytes != null) {
+ Base64.encode(bytes)
+ } else {
+ "Cannot encode file"
+ }
+ } catch(e: Exception){
+ e.printStackTrace()
+ return "Cannot encode file"}
+
+ }
+
+ @OptIn(ExperimentalEncodingApi::class)//Made by Craig
+ fun decodeBase64(inputbase64:String, output: File): File{//Decodes to a file. Uses base64
+ val decodedfilebytes = Base64.decode(inputbase64)
+ val decodedstrm = FileOutputStream(output)
+ decodedstrm.write(decodedfilebytes)
+ decodedstrm.close()
+ return output
+ }
+ fun sendImage(imageURI: Uri?, tgtaddress: InetAddress, tgtport:Int, appctxt: Context): Boolean{//Testing sending images
+ try{//we can utilize this if we opt not to use JSON
+ if(imageURI != null){
+ val fp = encodebase64(appctxt, imageURI)//encodes file to base64
+ if(!fp.equals("Cannot encode file")) {
+ val efp = URLEncoder.encode(fp, "UTF-8")//ensures that the file URI is utf-8 encoded
+ val connection =
+ URL("http://${tgtaddress.hostAddress}:${tgtport}/upload?file=$efp").openConnection() as HttpURLConnection
+ val request = "POST"//Specifies the request as a POST
+ connection.doOutput = true
+ connection.requestMethod = request
+ connection.setChunkedStreamingMode(0)
+ val instream = appctxt.contentResolver.openInputStream(imageURI)
+ val outstream = connection.outputStream
+ val readingbuffer = ByteArray(1024)
+ var finishedreading: Int
+ while (instream?.read(readingbuffer).also { finishedreading = it!! } != -1) {
+ outstream.write(readingbuffer, 0, finishedreading)
+ }
+ outstream.close()
+ instream?.close()
+
+ } else {
+ return false
+ }} else {
+ return false
+ }
+ }
+ catch(e: Exception){
+ e.printStackTrace()
+ return false
+ }
+ return true
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/JSONSchema.kt b/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/JSONSchema.kt
new file mode 100644
index 00000000..d7db4d44
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/JSONSchema.kt
@@ -0,0 +1,49 @@
+package com.greybox.projectmesh.messaging.data.entities
+
+import org.json.JSONObject
+import org.json.JSONException
+import timber.log.Timber
+
+class JSONSchema {
+
+ private val schemaString = """
+{
+ "type": "object",
+ "required": ["id", "chat", "content", "dateReceived", "sender"],
+ "properties": {
+ "id": { "type": "integer" },
+ "chat": { "type": "string" },
+ "content": { "type": "string" },
+ "dateReceived": { "type": "integer" },
+ "sender": { "type": "string" },
+ "file": { "type": "string", "format": "uri" }
+ }
+}
+"""
+ //Takes JSON string and validates it against JSON Schema
+ fun schemaValidation(json: String): Boolean {
+ //Timber.tag("JSONSchema").d("Validating JSON: $json")
+ //Timber.tag("JSONSchema").d("Against schema: $schemaString")
+ try {
+ val schemaJson = JSONObject(schemaString)
+ val jsonObject = JSONObject(json)
+
+ validate(jsonObject, schemaJson)
+ return true
+ }catch (e: JSONException) {
+ Timber.tag("JSONSchema",).e("JSON schema validation failed: ${e.message}")
+ return false
+ }
+ }
+
+ //Validates JSON object against schema
+ private fun validate(json: JSONObject, schema: JSONObject) {
+ val requiredFields = schema.getJSONArray("required")
+ for (i in 0 until requiredFields.length()) {
+ val field = requiredFields.getString(i)
+ if (!json.has(field)) {
+ throw JSONException("Missing required field: $field")
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/Message.kt b/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/Message.kt
new file mode 100644
index 00000000..f48afdd8
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/data/entities/Message.kt
@@ -0,0 +1,46 @@
+package com.greybox.projectmesh.messaging.data.entities
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import androidx.room.TypeConverter
+import androidx.room.TypeConverters
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import java.net.URI
+class URIConverter{
+ @TypeConverter
+ fun convfromURI(theuri: URI?): String?{
+ return theuri?.toString()
+ }
+ @TypeConverter
+ fun convtoURI(uristring: String?): URI?{
+ return uristring?.let{URI.create(it)}
+ }
+}
+object URISerializable : KSerializer {//This makes the URI serializable, can be used in JSON
+ override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("URI", PrimitiveKind.STRING)
+ override fun serialize(enc: Encoder, vals: URI) {
+ enc.encodeString(vals.toString())
+ }
+ override fun deserialize(dec: Decoder): URI {
+ return URI.create(dec.decodeString())
+ }
+}
+@Serializable
+@Entity(tableName = "message")
+@TypeConverters(URIConverter::class)
+data class Message(//
+ @PrimaryKey(autoGenerate = true) val id: Int,
+ @ColumnInfo(name = "dateReceived") val dateReceived: Long,
+ @ColumnInfo(name = "content") val content: String,
+ @ColumnInfo(name = "sender") val sender: String,
+ @ColumnInfo(name = "chat") val chat: String,
+ @ColumnInfo(name= "file") @Serializable(with=URISerializable::class) val file: URI? = null
+ //@ColumnInfo(name = "file") @Serializable(with=URISerializable::class) val file: List
+)
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/images/ConversationsScreenFirstImpressions.png b/app/src/main/java/com/greybox/projectmesh/messaging/images/ConversationsScreenFirstImpressions.png
new file mode 100644
index 00000000..6bf9dd28
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/messaging/images/ConversationsScreenFirstImpressions.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/images/InitialChatScreenFirstTimeChatting.png b/app/src/main/java/com/greybox/projectmesh/messaging/images/InitialChatScreenFirstTimeChatting.png
new file mode 100644
index 00000000..cd798615
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/messaging/images/InitialChatScreenFirstTimeChatting.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/images/ReadIndicatorsUpdating.png b/app/src/main/java/com/greybox/projectmesh/messaging/images/ReadIndicatorsUpdating.png
new file mode 100644
index 00000000..00816d93
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/messaging/images/ReadIndicatorsUpdating.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/images/RecievedMessageChatScreen.png b/app/src/main/java/com/greybox/projectmesh/messaging/images/RecievedMessageChatScreen.png
new file mode 100644
index 00000000..0df7a296
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/messaging/images/RecievedMessageChatScreen.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/images/RecievedMessageConvoScreen.png b/app/src/main/java/com/greybox/projectmesh/messaging/images/RecievedMessageConvoScreen.png
new file mode 100644
index 00000000..c507c456
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/messaging/images/RecievedMessageConvoScreen.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/images/SentMessage.png b/app/src/main/java/com/greybox/projectmesh/messaging/images/SentMessage.png
new file mode 100644
index 00000000..3cf60b89
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/messaging/images/SentMessage.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/network/MessageNetworkHandler.kt b/app/src/main/java/com/greybox/projectmesh/messaging/network/MessageNetworkHandler.kt
new file mode 100644
index 00000000..669671ef
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/network/MessageNetworkHandler.kt
@@ -0,0 +1,236 @@
+// Path: app/src/main/java/com/greybox/projectmesh/messaging/network/MessageNetworkHandler.kt
+package com.greybox.projectmesh.messaging.network
+
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import androidx.core.app.NotificationCompat
+import com.greybox.projectmesh.GlobalApp
+import com.greybox.projectmesh.MainActivity
+import com.greybox.projectmesh.R
+import com.greybox.projectmesh.messaging.data.entities.Conversation
+import com.greybox.projectmesh.messaging.data.entities.Message
+import com.greybox.projectmesh.messaging.utils.ConversationUtils
+import com.greybox.projectmesh.messaging.repository.ConversationRepository
+import com.greybox.projectmesh.server.AppServer
+import com.greybox.projectmesh.testing.TestDeviceService
+import java.net.InetAddress
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import okhttp3.HttpUrl
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import org.kodein.di.DI
+import org.kodein.di.DIAware
+import org.kodein.di.instance
+import android.content.SharedPreferences
+import timber.log.Timber
+import java.net.URI
+
+class MessageNetworkHandler(
+ private val httpClient: OkHttpClient,
+ private val localVirtualAddr: InetAddress,
+ override val di: DI
+) : DIAware {
+ private val scope = CoroutineScope(Dispatchers.IO)
+ private val conversationRepository: ConversationRepository by di.instance()
+ private val settingsPrefs: SharedPreferences by di.instance(tag = "settings")
+
+ //function sendChatMessage(address: InetAddress, time: Long, message: String) {
+ fun sendChatMessage(address: InetAddress, time: Long, message: String, file: URI?/* test this*/) {
+ scope.launch {
+ try {
+ val httpUrl = HttpUrl.Builder()
+ .scheme("http")
+ .host(address.hostAddress)
+ .port(AppServer.DEFAULT_PORT)
+ .addPathSegment("chat")
+ .addQueryParameter("chatMessage", message)
+ .addQueryParameter("time", time.toString())
+ .addQueryParameter("senderIp", localVirtualAddr.hostAddress)
+ .apply {
+ if (file != null) {
+ addQueryParameter("incomingfile", file.toString())
+ }
+ }
+ .build()
+
+ val request = Request.Builder()
+ .url(httpUrl)
+ .get()
+ .build()
+
+ Timber.tag("MessageNetworkHandler").d("Request URL: ${request.url}")
+ //Turn this into JSON
+ /*
+ val gs = Gson()
+ val msg = Message(
+ id = 0,
+ dateReceived = time,
+ content = message,
+ sender = localVirtualAddr.hostName,
+ chat = address.hostAddress,
+ file = file
+ )
+ val jsmsg = gs.toJson(msg)
+ //send
+ */
+
+ // Use try-with-resources pattern to ensure resources are closed
+ try {
+ httpClient.newCall(request).execute().use { response ->
+ if (response.isSuccessful) {
+ Timber.tag("MessageNetworkHandler").d("Message sent successfully")
+ } else {
+ Timber.tag("MessageNetworkHandler").e("Failed to send message: " +
+ "${response
+ .code}")
+ }
+ }
+ } catch (e: Exception) {
+ Timber.tag("MessageNetworkHandler").e(e,"Failed to send message, connection " +
+ "error: ${e.message}")
+ }
+
+ } catch (e: Exception) {
+ Timber.tag("MessageNetworkHandler").e("Failed to send message to ${address
+ .hostAddress}")
+ }
+ }
+ }
+ companion object {
+ //process incoming messages and route them to the correct conversation
+ fun handleIncomingMessage(
+ chatMessage: String?,
+ time: Long,
+ senderIp: InetAddress,
+ incomingfile: URI?
+ ): Message {
+ Timber.tag(
+ "MessageNetworkHandler").d(
+ "Handling incoming message: $chatMessage, from: ${senderIp.hostAddress}, has file: ${incomingfile != null}"
+ )
+
+ val ipStr = senderIp.hostAddress
+ val user = runBlocking { GlobalApp.GlobalUserRepo.userRepository.getUserByIp(ipStr) }
+ val sender = user?.name ?: "Unknown"
+
+ //determine the correct chat name
+ val userUuid = when {
+ TestDeviceService.isOnlineTestDevice(senderIp) ->
+ "test-device-uuid"
+
+ ipStr == TestDeviceService.TEST_DEVICE_IP_OFFLINE || user?.name == TestDeviceService.TEST_DEVICE_NAME_OFFLINE ->
+ "offline-test-device-uuid"
+
+ else -> user?.uuid ?: "unknown-${senderIp.hostAddress}"
+ }
+
+ val localUuid = GlobalApp.GlobalUserRepo.prefs.getString("UUID", null) ?: "local-user"
+ val chatName = ConversationUtils.createConversationId(localUuid, userUuid)
+
+ Timber.tag(
+ "MessageNetworkHandler").d(
+ "Creating message with chat name: $chatName, sender: $sender"
+ )
+
+ //Create the message
+ val message = Message(
+ id = 0,
+ dateReceived = time,
+ content = chatMessage ?: "Error! No message found.",
+ sender = sender,
+ chat = chatName,
+ file = incomingfile//will be null for reg text messages
+ )
+
+ //update convo with new message
+ if (user != null) {
+ try {
+ //get/create convo
+ val conversation = runBlocking {
+ GlobalApp.GlobalUserRepo.conversationRepository.getOrCreateConversation(
+ localUuid = localUuid,
+ remoteUser = user
+ )
+ }
+
+ //update convo with the new message
+ runBlocking {
+ GlobalApp.GlobalUserRepo.conversationRepository.updateWithMessage(
+ conversationId = conversation.id,
+ message = message
+ )
+ }
+
+ Timber.tag("MessageNetworkHandler").d("Updated conversation with new message")
+ } catch (e: Exception) {
+ Timber.tag("MessageNetworkHandler").e(e,"Failed to update conversation")
+ }
+ }
+ return message
+ }
+
+
+ // New helper function to show notifications that route to chat screen
+ private fun showMessageNotification(
+ conversation: Conversation,
+ message: Message,
+ senderIp: InetAddress
+ ) {
+ try {
+ // get context
+ val context = try {
+ GlobalApp.GlobalUserRepo.userRepository.javaClass.classLoader?.loadClass("com.greybox.projectmesh.GlobalApp")
+ ?.getDeclaredField("INSTANCE")?.get(null) as? Context
+ ?: throw Exception("Cannot get application context")
+ } catch (e: Exception) {
+ Timber.tag("MessageNetworkHandler").e(e,"Failed to get application context")
+ return
+ }
+
+ // Determine title and content based on whether there's a file
+ val hasFile = message.file != null
+ val title = if (hasFile) "New message with file" else "New message"
+ val content = "From ${conversation.userName}: ${message.content}"
+
+ // Create intent that routes to the chat screen
+ val intent = Intent(context, MainActivity::class.java).apply {
+ action = "OPEN_CHAT_SCREEN"
+ putExtra("ip", senderIp.hostAddress)
+ flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+ }
+
+ val pendingIntent = PendingIntent.getActivity(
+ context,
+ message.hashCode(),
+ intent,
+ PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+ )
+
+ val channelId = "file_receive_channel"
+
+ val notification = NotificationCompat.Builder(context, channelId)
+ .setSmallIcon(R.drawable.ic_launcher_foreground)
+ .setContentTitle(title)
+ .setContentText(content)
+ .setPriority(NotificationCompat.PRIORITY_HIGH)
+ .setDefaults(NotificationCompat.DEFAULT_VIBRATE or NotificationCompat.DEFAULT_SOUND)
+ .setContentIntent(pendingIntent)
+ .setAutoCancel(true)
+ .build()
+
+ val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+ notificationManager.notify(message.hashCode(), notification)
+
+ Timber.tag("MessageNetworkHandler").d("Showed notification for message with file")
+ } catch (e: Exception) {
+ Timber.tag("MessageNetworkHandler").e(e, "Failed to show notification")
+ }
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/network/MessageService.kt b/app/src/main/java/com/greybox/projectmesh/messaging/network/MessageService.kt
new file mode 100644
index 00000000..1867f0a9
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/network/MessageService.kt
@@ -0,0 +1,64 @@
+// Path: app/src/main/java/com/greybox/projectmesh/messaging/network/MessageService.kt
+package com.greybox.projectmesh.messaging.network
+
+import android.content.SharedPreferences
+import com.greybox.projectmesh.messaging.repository.MessageRepository
+import com.greybox.projectmesh.messaging.data.entities.Message
+import com.greybox.projectmesh.messaging.repository.ConversationRepository
+import com.greybox.projectmesh.user.UserRepository
+import java.net.InetAddress
+import org.kodein.di.DI
+import org.kodein.di.DIAware
+import org.kodein.di.instance
+import timber.log.Timber
+
+class MessageService(
+ override val di: DI
+) : DIAware {
+ private val messageNetworkHandler: MessageNetworkHandler by di.instance()
+ private val messageRepository: MessageRepository by di.instance()
+ private val conversationRepository: ConversationRepository by di.instance()
+ private val userRepository: UserRepository by di.instance()
+ private val settingsPrefs: SharedPreferences by di.instance(tag = "settings")
+
+ suspend fun sendMessage(address: InetAddress, message: Message) {
+ //First save locally
+ messageRepository.addMessage(message)
+
+ //Then send over network
+ messageNetworkHandler.sendChatMessage(
+ address = address,
+ time = message.dateReceived,
+ message = message.content,
+ file = null
+ )
+ }
+
+ private suspend fun updateConversationWithMessage(address: InetAddress, message: Message){
+ try {
+ //find user by ip address
+ val ipStr = address.hostAddress
+ val user = userRepository.getUserByIp(ipStr)
+
+ if (user != null) {
+ //user found -> create or update the convo
+ val localUuid = settingsPrefs.getString("UUID", null) ?: "local-user"
+
+ //get or create the convo
+ val conversation = conversationRepository.getOrCreateConversation(
+ localUuid = localUuid,
+ remoteUser = user,
+ )
+
+ //update the conversation with the message
+ conversationRepository.updateWithMessage(
+ conversationId = conversation.id,
+ message = message
+ )
+
+ }
+ }catch (e: Exception){
+ Timber.tag("MessageService").e(e,"Error updating conversation with message")
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/repository/ConversationRepository.kt b/app/src/main/java/com/greybox/projectmesh/messaging/repository/ConversationRepository.kt
new file mode 100644
index 00000000..bb90d1dc
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/repository/ConversationRepository.kt
@@ -0,0 +1,110 @@
+package com.greybox.projectmesh.messaging.repository
+
+import com.greybox.projectmesh.messaging.data.dao.ConversationDao
+import com.greybox.projectmesh.messaging.data.entities.Conversation
+import com.greybox.projectmesh.messaging.data.entities.Message
+import com.greybox.projectmesh.messaging.utils.ConversationUtils
+import com.greybox.projectmesh.user.UserEntity
+import kotlinx.coroutines.flow.Flow
+import org.kodein.di.DI
+import org.kodein.di.DIAware
+import timber.log.Timber
+
+class ConversationRepository(
+ private val conversationDao: ConversationDao,
+ override val di: DI
+) : DIAware {
+
+ //get all conversations as a flow
+ fun getAllConversations(): Flow>{
+ return conversationDao.getAllConversationsFlow()
+ }
+
+ //get specific convo by id
+ suspend fun getConversationById(conversationId: String): Conversation? {
+ Timber.tag("ConversationRepository").d("Getting conversation by ID: $conversationId")
+ val result = conversationDao.getConversationById(conversationId)
+ Timber.tag("ConversationRepository").d("Result for ID $conversationId: ${result != null}")
+ return result
+ }
+
+ suspend fun getOrCreateConversation(localUuid: String, remoteUser: UserEntity): Conversation {
+ //create a unique conversation ID using both UUIDs in order to ensure consistency
+ val conversationId = ConversationUtils.createConversationId(localUuid, remoteUser.uuid)
+
+ Timber.tag("ConversationRepository").d("Looking for conversation with ID: $conversationId")
+ Timber.tag("ConversationRepository").d("Local UUID: $localUuid, Remote UUID: ${remoteUser
+ .uuid}")
+
+ //try to get an existing conversation
+ var conversation = conversationDao.getConversationById(conversationId)
+
+ //if no conversation exists, create a new one
+ if(conversation == null){
+ Timber.d("ConversationRepository", "Conversation not found, creating new one with ${remoteUser.name}")
+
+ conversation = Conversation(
+ id = conversationId,
+ userUuid = remoteUser.uuid,
+ userName = remoteUser.name,
+ userAddress = remoteUser.address,
+ lastMessage = null,
+ lastMessageTime = System.currentTimeMillis(),
+ unreadCount = 0,
+ isOnline = remoteUser.address != null
+ )
+ conversationDao.insertConversation(conversation)
+ Timber.tag("ConversationRepository").d("Created new conversation with ${remoteUser
+ .name}")
+ } else {
+ Timber.tag("ConversationRepository").d("Found existing conversation with ${remoteUser
+ .name}")
+ }
+ return conversation
+ }
+
+ //update conversation with the latest message
+ suspend fun updateWithMessage(conversationId: String, message: Message) {
+
+ conversationDao.updateLastMessage(
+ conversationId = conversationId,
+ lastMessage = message.content,
+ timestamp = message.dateReceived
+ )
+
+ //if this is a received message (not sent by self) increment unread count
+ if (message.sender != "Me") {
+ conversationDao.incrementUnreadCount(conversationId)
+ }
+
+ conversationDao.updateLastMessage(
+ conversationId = conversationId,
+ lastMessage = message.content,
+ timestamp = message.dateReceived
+ )
+
+ }
+
+ //mark conversation as read
+ suspend fun markAsRead(conversationId: String) {
+ conversationDao.clearUnreadCount(conversationId)
+ }
+
+ //update a user's online status
+ suspend fun updateUserStatus(userUuid: String, isOnline: Boolean, userAddress: String?) {
+ try {
+ // Update in database
+ conversationDao.updateUserConnectionStatus(
+ userUuid = userUuid,
+ isOnline = isOnline,
+ userAddress = userAddress
+ )
+
+ // Log for debugging
+ Timber.tag("ConversationRepository").d("Updated user $userUuid connection status: online=$isOnline, address=$userAddress")
+ } catch (e: Exception) {
+ Timber.tag("ConversationRepository").e(e,"Failed to update user connection status")
+ }
+ }
+
+}
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/repository/MessageRepository.kt b/app/src/main/java/com/greybox/projectmesh/messaging/repository/MessageRepository.kt
new file mode 100644
index 00000000..adf8b069
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/repository/MessageRepository.kt
@@ -0,0 +1,34 @@
+// Path: app/src/main/java/com/greybox/projectmesh/messaging/repository/MessageRepository.kt
+package com.greybox.projectmesh.messaging.repository
+
+import com.greybox.projectmesh.messaging.data.dao.MessageDao
+import com.greybox.projectmesh.messaging.data.entities.Message
+import kotlinx.coroutines.flow.Flow
+import org.kodein.di.DI
+import org.kodein.di.DIAware
+
+// Changed to use Kodein instead of javax.inject
+class MessageRepository(
+ private val messageDao: MessageDao,
+ override val di: DI
+) : DIAware {
+ // Get all messages for a chat
+ fun getChatMessages(chatId: String): Flow> {
+ return messageDao.getChatMessagesFlow(chatId)
+ }
+
+ // Add a new message
+ suspend fun addMessage(message: Message) {
+ messageDao.addMessage(message)
+ }
+
+ // Get all messages
+ fun getAllMessages(): Flow> {
+ return messageDao.getAllFlow()
+ }
+
+ // Clear all messages
+ suspend fun clearMessages() {
+ messageDao.clearTable()
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/ui/models/ChatScreenModel.kt b/app/src/main/java/com/greybox/projectmesh/messaging/ui/models/ChatScreenModel.kt
new file mode 100644
index 00000000..a0e5b60b
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/ui/models/ChatScreenModel.kt
@@ -0,0 +1,11 @@
+package com.greybox.projectmesh.messaging.ui.models
+
+import com.greybox.projectmesh.messaging.data.entities.Message
+import java.net.InetAddress
+
+data class ChatScreenModel(
+ val deviceName: String? = null,
+ val virtualAddress: InetAddress = InetAddress.getByName("192.168.0.1"),
+ val allChatMessages: List = emptyList(),
+ val offlineWarning: String? = null
+)
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/ui/models/ConversationsHomeScreenModel.kt b/app/src/main/java/com/greybox/projectmesh/messaging/ui/models/ConversationsHomeScreenModel.kt
new file mode 100644
index 00000000..2c3fd30d
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/ui/models/ConversationsHomeScreenModel.kt
@@ -0,0 +1,9 @@
+package com.greybox.projectmesh.messaging.ui.models
+
+import com.greybox.projectmesh.messaging.data.entities.Conversation
+
+data class ConversationsHomeScreenModel (
+ val isLoading: Boolean = false,
+ val conversations: List = emptyList(),
+ val error: String? = null
+)
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/ui/screens/ChatNodeListScreen.kt b/app/src/main/java/com/greybox/projectmesh/messaging/ui/screens/ChatNodeListScreen.kt
new file mode 100644
index 00000000..90c1b3d0
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/ui/screens/ChatNodeListScreen.kt
@@ -0,0 +1,49 @@
+package com.greybox.projectmesh.messaging.ui.screens
+
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.greybox.projectmesh.ViewModelFactory
+import com.greybox.projectmesh.viewModel.NetworkScreenViewModel
+import com.greybox.projectmesh.extension.WifiListItem
+import org.kodein.di.compose.localDI
+import androidx.compose.ui.platform.LocalSavedStateRegistryOwner
+import com.greybox.projectmesh.viewModel.NetworkScreenModel
+
+@Composable
+fun ChatNodeListScreen(
+ onNodeSelected: (String) -> Unit,
+ // Reuse NetworkScreenViewModel in the same way as NetworkScreen
+ viewModel: NetworkScreenViewModel = viewModel(
+ factory = ViewModelFactory(
+ di = localDI(),
+ owner = LocalSavedStateRegistryOwner.current,
+ vmFactory = { di, savedStateHandle ->
+ NetworkScreenViewModel(di, savedStateHandle)
+ },
+ defaultArgs = null
+ )
+ )
+) {
+ // Provide the same initial state you used in NetworkScreen
+ val uiState: NetworkScreenModel by viewModel.uiState.collectAsState(initial = NetworkScreenModel())
+
+ LazyColumn {
+ items(
+ items = uiState.allNodes.entries.toList(),
+ key = { it.key }
+ ) { nodeEntry ->
+ // Tapping a WifiListItem calls 'onNodeSelected' instead of onClickNetworkNode
+ WifiListItem(
+ wifiAddress = nodeEntry.key,
+ wifiEntry = nodeEntry.value,
+ onClick = { selectedIp ->
+ onNodeSelected(selectedIp)
+ }
+ )
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/ui/screens/ChatScreen.kt b/app/src/main/java/com/greybox/projectmesh/messaging/ui/screens/ChatScreen.kt
new file mode 100644
index 00000000..9d3cfab0
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/ui/screens/ChatScreen.kt
@@ -0,0 +1,515 @@
+// app/src/main/java/com/greybox/projectmesh/messaging/ui/screens/ChatScreen.kt
+
+package com.greybox.projectmesh.messaging.ui.screens
+
+import android.net.Uri
+import android.os.Bundle
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.border
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.AttachFile
+import androidx.compose.material.icons.filled.SignalWifiOff
+import androidx.compose.material3.Button
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextField
+import androidx.compose.material3.Card
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.runtime.remember
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.sp
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalSavedStateRegistryOwner
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.greybox.projectmesh.DeviceStatusManager
+import com.greybox.projectmesh.GlobalApp
+import com.greybox.projectmesh.ViewModelFactory
+import com.greybox.projectmesh.messaging.data.entities.Message
+import com.greybox.projectmesh.messaging.ui.models.ChatScreenModel
+import com.greybox.projectmesh.messaging.ui.viewmodels.ChatScreenViewModel
+import com.greybox.projectmesh.server.AppServer
+import com.greybox.projectmesh.views.LongPressCopyableText
+import com.greybox.projectmesh.testing.TestDeviceService
+import kotlinx.coroutines.runBlocking
+import org.kodein.di.compose.localDI
+import java.net.InetAddress
+import java.text.SimpleDateFormat
+import java.util.Date
+import android.provider.OpenableColumns
+import org.kodein.di.instance
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import timber.log.Timber
+
+@Composable
+fun ChatScreen(
+ virtualAddress: InetAddress,
+ userName: String? = null,
+ isOffline: Boolean = false,
+ onClickButton: () -> Unit,
+ viewModel: ChatScreenViewModel = viewModel(
+ factory = ViewModelFactory(
+ di = localDI(),
+ owner = LocalSavedStateRegistryOwner.current,
+ vmFactory = { di, savedStateHandle ->
+ ChatScreenViewModel(di, savedStateHandle)
+ },
+ defaultArgs = Bundle().apply {
+ putSerializable("virtualAddress", virtualAddress)
+
+ }
+ )
+ )
+) {
+
+ //get user info
+ val userInfo = remember {
+ if (userName != null) {
+ //use provided userName if available
+ userName
+ } else {
+ //else try to look it up from the repository
+ runBlocking {
+ GlobalApp.GlobalUserRepo.userRepository.getUserByIp(virtualAddress.hostAddress)?.name
+ ?: "Unknown User"
+ }
+ }
+ }
+
+ // Track device status from DeviceStatusManager
+ var deviceStatus by remember { mutableStateOf(false) }
+
+ // Only observe for real devices (not placeholders)
+ val shouldTrackStatus = remember {
+ virtualAddress.hostAddress != "0.0.0.0" &&
+ virtualAddress.hostAddress != TestDeviceService.TEST_DEVICE_IP_OFFLINE
+ }
+
+ if (shouldTrackStatus) {
+ // Collect directly from DeviceStatusManager
+ val statusMap by DeviceStatusManager.deviceStatusMap.collectAsState()
+
+ // Use LaunchedEffect with a key derived from the status map entry for this device
+ LaunchedEffect(statusMap[virtualAddress.hostAddress]) {
+ val newStatus = statusMap[virtualAddress.hostAddress] ?: false
+ if (deviceStatus != newStatus) {
+ Timber.tag(
+ "ChatScreen")
+ .d("Device status changed: ${virtualAddress.hostAddress} is now ${if
+ (newStatus) "online" else "offline"}"
+ )
+ deviceStatus = newStatus
+ }
+ }
+ }
+
+ //Grab AppServer fromm local DI
+ val di = localDI()
+ val appServer: AppServer by di.instance()
+
+ val contextMessageForFile = LocalContext.current
+
+ // set up the system file-picker
+ val pickFileLauncher = rememberLauncherForActivityResult(
+ ActivityResultContracts.GetContent()
+ ) { uri: Uri? ->
+ uri?.let { selectedUri ->
+ // 1) start the transfer
+ appServer.addOutgoingTransfer(selectedUri, virtualAddress)
+
+ //Get name of file
+ var displayName = "unknown"
+ contextMessageForFile.contentResolver
+ .query(selectedUri, arrayOf(OpenableColumns.DISPLAY_NAME), null, null, null)
+ ?.use { cursor ->
+ if (cursor.moveToFirst()) {
+ cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+ .takeIf { it >= 0 }
+ ?.let { idx ->
+ displayName = cursor.getString(idx)
+ }
+ }
+ }
+ //Send a chat message when file is sent via file transfer
+ viewModel.sendChatMessage(
+ virtualAddress,
+ "File $displayName was sent",
+ null
+ )
+ }
+ }
+ // declare the UI state, we can use the uiState to access the current state of the viewModel
+ val uiState: ChatScreenModel by viewModel.uiState.collectAsState(initial = ChatScreenModel())
+ var textMessage by rememberSaveable { mutableStateOf("") }
+
+ val context = LocalContext.current
+
+ val scrollState = rememberScrollState()
+
+ Box(modifier = Modifier.fillMaxSize()) {
+ Column(modifier = Modifier
+ .fillMaxSize()
+ .padding(bottom = 72.dp)) {
+
+ //add a status bar at the top of the chat
+ UserStatusBar(
+ userName = userInfo,
+ isOnline = deviceStatus,
+ userAddress = virtualAddress.hostAddress
+ )
+
+ // Show device status indicator
+ if (!deviceStatus) {
+ Card(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(8.dp),
+ colors = CardDefaults.cardColors(
+ containerColor = MaterialTheme.colorScheme.errorContainer
+ )
+ ){
+ Row(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(16.dp),
+ verticalAlignment = Alignment.CenterVertically
+ ){
+ Icon(
+ imageVector = Icons.Default.SignalWifiOff,
+ contentDescription = null,
+ tint = MaterialTheme.colorScheme.error
+ )
+ Spacer(modifier = Modifier.width(8.dp))
+ Text(
+ text = "User is offline. Messages cannot be sent.",
+ color = MaterialTheme.colorScheme.error
+ )
+ }
+ }
+ }
+
+ DisplayAllMessages(uiState, onClickButton)
+ }
+ Row(modifier = Modifier
+ .fillMaxWidth()
+ .align(Alignment.BottomCenter)
+ .padding(4.dp),
+ verticalAlignment = Alignment.Bottom //Change the Alignment So that it does not
+ // increase the height together with the TextField and be floating in the middle of the
+ // screen
+ ) {
+
+ //File Picker Button
+ IconButton(
+ modifier = Modifier
+ .clip(CircleShape)
+ .border(2.dp, Color.Gray, CircleShape)
+ .size(40.dp),
+ onClick = { pickFileLauncher.launch("*/*") }
+ ) {
+ Icon(
+ imageVector = Icons.Default.AttachFile,
+ contentDescription = "Select a file to send"
+ )
+ }
+ TextField(
+ modifier = Modifier
+ .weight(3f)
+ .heightIn(min = 40.dp, max = 120.dp) // Added Min and Max Height to the
+ // TextField
+ .verticalScroll(scrollState),
+ value = textMessage,
+ onValueChange = {
+ textMessage = it
+ },
+ maxLines = 5,
+ enabled = deviceStatus // disable text input when user is offline
+ )
+ Button(modifier = Modifier.weight(1f), onClick = {
+ val message = textMessage.trimEnd()
+ //val imgpath = "sdcard/padorubastard.jpg"//test image path
+ //future implementation should implement file picker
+ //val filepath = Uri.parse(imgpath)
+ if(message.isNotEmpty()) {
+ viewModel.sendChatMessage(virtualAddress,message, null)
+ // resets the text field
+ textMessage = ""
+ }
+ },
+ enabled = deviceStatus //disable button when user is offline
+ ) {
+ Text(text = "Send")
+ }
+ }
+ }
+}
+
+@Composable
+fun UserStatusBar(
+ userName: String,
+ isOnline: Boolean,
+ userAddress: String
+){
+ Card(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(8.dp),
+ colors = CardDefaults.cardColors(
+ containerColor = if (isOnline)
+ MaterialTheme.colorScheme.primaryContainer
+ else
+ MaterialTheme.colorScheme.surfaceVariant
+ )
+ ) {
+ Row(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(16.dp),
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ //User avatar/icon
+ Box(
+ modifier = Modifier
+ .size(40.dp)
+ .clip(CircleShape)
+ .background(
+ if (isOnline)
+ MaterialTheme.colorScheme.primary
+ else
+ MaterialTheme.colorScheme.outline
+ ),
+ contentAlignment = Alignment.Center
+ ) {
+ Text(
+ text = userName.first().toString(),
+ color = Color.White,
+ fontSize = 20.sp
+ )
+ }
+
+ Spacer(modifier = Modifier.width(16.dp))
+
+ //User name and status
+ Column {
+ Text(
+ text = userName,
+ style = MaterialTheme.typography.titleMedium,
+ fontWeight = FontWeight.Bold
+ )
+
+ Row(
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ //Status indicator dot
+ Box(
+ modifier = Modifier
+ .size(8.dp)
+ .clip(CircleShape)
+ .background(
+ if (isOnline) Color.Green else Color.Gray
+ )
+ )
+
+ Spacer(modifier = Modifier.width(4.dp))
+
+ // Status text
+ Text(
+ text = if (isOnline) "Online" else "Offline",
+ style = MaterialTheme.typography.bodySmall,
+ color = MaterialTheme.colorScheme.onSurfaceVariant
+ )
+
+ Spacer(modifier = Modifier.width(12.dp))
+
+ // IP address
+ Text(
+ text = userAddress,
+ style = MaterialTheme.typography.bodySmall,
+ color = MaterialTheme.colorScheme.onSurfaceVariant,
+ fontSize = 10.sp
+ )
+ }
+ }
+ }
+ }
+}
+
+@Composable
+fun DisplayAllMessages(uiState: ChatScreenModel, onClickButton: () -> Unit) {
+ val context = LocalContext.current
+
+ //track if messages are showing:
+ val hasMessages = uiState.allChatMessages.isNotEmpty()
+
+ LaunchedEffect(uiState.allChatMessages.size) {
+ Timber.tag("ChatScreen").d("DisplayAllMessages with ${uiState.allChatMessages.size} %s",
+ "messages")
+ }
+
+ LazyColumn{
+ if (!hasMessages){
+ item {
+ Column(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(16.dp),
+ horizontalAlignment = Alignment.CenterHorizontally
+ ) {
+ Text(
+ text = "No messages yet. Start a conversation!",
+ modifier = Modifier.padding(16.dp),
+ style = MaterialTheme.typography.bodyLarge
+ )
+ if (uiState.offlineWarning != null) {
+ Text(
+ text = "You're currently offline. Any messages you send will be delivered when connection is restored.",
+ modifier = Modifier.padding(horizontal = 16.dp),
+ style = MaterialTheme.typography.bodyMedium,
+ color = MaterialTheme.colorScheme.error
+ )
+ }
+ }
+ }
+ }
+
+ items(
+ items = uiState.allChatMessages
+ ){ chatMessage ->
+ Timber.tag("ChatDebug").d("Rendering message: ${chatMessage.content}")
+ val sender: String = if (chatMessage.sender == "Me") {
+ "Me"
+ } else {
+ val ipStr = uiState.virtualAddress.hostAddress
+ val user = runBlocking {
+ GlobalApp.GlobalUserRepo.userRepository.getUserByIp(ipStr)
+ }
+ user?.name ?: chatMessage.sender
+ }
+
+ val sentBySelf = chatMessage.sender == "Me"
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ horizontalArrangement = if (sentBySelf) Arrangement.End else Arrangement.Start
+ ) {
+ MessageBubble(
+ chatMessage = chatMessage,
+ sentBySelf = sentBySelf,
+ messageContent = {
+ LongPressCopyableText(
+ context = context,
+ text = "",
+ textCopyable = chatMessage.content,
+ textSize = 15
+ )
+ },
+ sender = sender,
+ modifier = Modifier
+ )
+ }
+ }
+ }
+}
+
+@Composable
+fun MessageBubble(
+ chatMessage: Message,
+ sentBySelf: Boolean,
+ messageContent: @Composable () -> Unit,
+ sender: String,
+ modifier: Modifier
+){
+ val context = LocalContext.current
+
+ ElevatedCard(
+ colors = CardDefaults.cardColors(
+ containerColor = if(sentBySelf){
+ Color.Cyan
+ }else{
+ MaterialTheme.colorScheme.surfaceVariant
+ }
+ ),
+ modifier = modifier
+ .padding(10.dp)
+ .widthIn(max = 280.dp)
+ ) {
+ Column(modifier = Modifier.padding(4.dp)) {
+ Text(
+ text = sender,
+ style = MaterialTheme.typography.labelMedium
+ )
+
+ messageContent()
+ //ONLY SHOW FILE ATTACHMENT IF PRESENT
+ if (chatMessage.file != null) {
+ Spacer(modifier = Modifier.height(4.dp))
+ Row(
+ modifier = Modifier
+ .fillMaxWidth()
+ .background(
+ MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.3f),
+ RoundedCornerShape(4.dp)
+ )
+ .padding(4.dp),
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ Icon(
+ imageVector = Icons.Default.AttachFile,
+ contentDescription = "File",
+ modifier = Modifier.size(16.dp)
+ )
+ Spacer(modifier = Modifier.width(4.dp))
+ Text(
+ text = chatMessage.file.toString(),
+ style = MaterialTheme.typography.bodySmall,
+ maxLines = 1,
+ overflow = TextOverflow.Ellipsis
+ )
+ }
+ }
+ // Adding timestamp to bottom right of message bubble
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ horizontalArrangement = Arrangement.End
+ ) {
+ Text(
+ text = SimpleDateFormat("HH:mm").format(Date(chatMessage.dateReceived)),
+ style = MaterialTheme.typography.labelSmall
+ )
+ }
+ }
+ }
+}
+
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/ui/screens/ConversationsHomeScreen.kt b/app/src/main/java/com/greybox/projectmesh/messaging/ui/screens/ConversationsHomeScreen.kt
new file mode 100644
index 00000000..371fe36f
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/ui/screens/ConversationsHomeScreen.kt
@@ -0,0 +1,362 @@
+package com.greybox.projectmesh.messaging.ui.screens
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.border
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Chat
+import androidx.compose.material.icons.filled.Error
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material3.*
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalSavedStateRegistryOwner
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.greybox.projectmesh.ViewModelFactory
+import com.greybox.projectmesh.messaging.data.entities.Conversation
+import com.greybox.projectmesh.messaging.ui.models.ConversationsHomeScreenModel
+import com.greybox.projectmesh.messaging.ui.viewmodels.ConversationsHomeScreenViewModel
+import com.greybox.projectmesh.messaging.utils.MessageUtils
+import org.kodein.di.compose.localDI
+
+@Composable
+fun ConversationsHomeScreen(
+ onConversationSelected: (String) -> Unit,
+ viewModel: ConversationsHomeScreenViewModel = viewModel(
+ factory = ViewModelFactory(
+ di = localDI(),
+ owner = LocalSavedStateRegistryOwner.current,
+ vmFactory = { di, _ ->
+ ConversationsHomeScreenViewModel(di)
+ },
+ defaultArgs = null
+ )
+ )
+){
+ val uiState: ConversationsHomeScreenModel by viewModel.uiState.collectAsState(
+ initial = ConversationsHomeScreenModel(isLoading = true)
+ )
+
+ Box(modifier = Modifier.fillMaxSize()) {
+ when {
+ uiState.isLoading -> {
+ CircularProgressIndicator(
+ modifier = Modifier.align(Alignment.Center)
+ )
+ }
+ uiState.error != null -> {
+ ErrorView(
+ errorMessage = uiState.error!!,
+ onRetry = { viewModel.refreshConversations() }
+ )
+ }
+ uiState.conversations.isEmpty() -> {
+ EmptyConversationsView()
+ }
+ else -> {
+ ConversationsList(
+ conversations = uiState.conversations,
+ onConversationClick = { conversation ->
+ //mark as read when opening the conversation
+ viewModel.markConversationAsRead(conversation.id)
+
+ //when user is online (has an IP address), navigate to chat
+ if (conversation.isOnline && conversation.userAddress != null) {
+ onConversationSelected(conversation.userAddress)
+ } else {
+ //when user if offline, still show the chat history ->
+ // handle in MainActivity with a disabled send button
+ onConversationSelected(conversation.id)
+ }
+ }
+ )
+ }
+ }
+ }
+}
+
+@Composable
+fun ConversationsList(
+ conversations: List,
+ onConversationClick: (Conversation) -> Unit
+) {
+ LazyColumn(
+ modifier = Modifier.fillMaxSize(),
+ contentPadding = PaddingValues(vertical = 8.dp)
+ ) {
+ items(conversations) { conversation ->
+ ConversationItem(
+ conversation = conversation,
+ onClick = { onConversationClick(conversation) }
+ )
+ Divider(
+ modifier = Modifier.padding(start = 72.dp, end = 16.dp),
+ color = MaterialTheme.colorScheme.surfaceVariant
+ )
+ }
+ }
+}
+
+@Composable
+fun ConversationItem(
+ conversation: Conversation,
+ onClick: () -> Unit
+) {
+ Row(
+ modifier = Modifier
+ .fillMaxWidth()
+ .clickable(onClick = onClick)
+ .padding(16.dp),
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ //avatar/profile picture with online status indicator
+ Box(
+ modifier = Modifier
+ .size(48.dp)
+ .clip(CircleShape)
+ .background(
+ color = if (conversation.isOnline)
+ MaterialTheme.colorScheme.primary
+ else
+ MaterialTheme.colorScheme.surfaceVariant
+ )
+ .border(
+ width = 2.dp,
+ color = if (conversation.isOnline) Color.Green else Color.Transparent,
+ shape = CircleShape
+ ),
+ contentAlignment = Alignment.Center
+ ) {
+ Text(
+ text = conversation.userName.firstOrNull()?.toString() ?: "?",
+ color = Color.White,
+ fontSize = 20.sp
+ )
+
+ //online status indicator
+ if (conversation.isOnline) {
+ Box(
+ modifier = Modifier
+ .size(12.dp)
+ .clip(CircleShape)
+ .background(Color.Green)
+ .border(1.dp, Color.White, CircleShape)
+ .align(Alignment.BottomEnd)
+ )
+ }
+ }
+
+ Spacer(modifier = Modifier.width(16.dp))
+
+ Column(
+ modifier = Modifier.weight(1f)
+ ) {
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ horizontalArrangement = Arrangement.SpaceBetween,
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ Row(
+ verticalAlignment = Alignment.CenterVertically
+ ){
+ Text(
+ text = conversation.userName,
+ style = MaterialTheme.typography.titleMedium,
+ fontWeight = FontWeight.Bold
+ )
+
+ Spacer (modifier = Modifier.width(8.dp))
+
+ //status indicator text
+ if (conversation.isOnline) {
+ Text (
+ text = "Online",
+ style = MaterialTheme.typography.labelSmall,
+ color = Color.Green,
+ fontSize = 10.sp
+ )
+ }
+ }
+
+ //show the timestamp of the last message
+ Text(
+ text = if (conversation.lastMessageTime > 0) {
+ MessageUtils.formatTimestamp(conversation.lastMessageTime)
+ } else {
+ ""
+ },
+ style = MaterialTheme.typography.labelSmall,
+ color = MaterialTheme.colorScheme.onSurfaceVariant
+ )
+
+ // Unread count badge
+ if (conversation.unreadCount > 0) {
+ Box(
+ modifier = Modifier
+ .size(24.dp)
+ .clip(CircleShape)
+ .background(MaterialTheme.colorScheme.primary),
+ contentAlignment = Alignment.Center
+ ) {
+ Text(
+ text = conversation.unreadCount.toString(),
+ color = MaterialTheme.colorScheme.onPrimary,
+ style = MaterialTheme.typography.labelSmall
+ )
+ }
+ }
+ }
+
+ Spacer(modifier = Modifier.height(4.dp))
+
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ horizontalArrangement = Arrangement.SpaceBetween,
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ //last message with status indicator
+ Row(
+ verticalAlignment = Alignment.CenterVertically,
+ modifier = Modifier.weight(1f)
+ ) {
+ //online/offline indicator
+ Box(
+ modifier = Modifier
+ .size(8.dp)
+ .clip(CircleShape)
+ .background(
+ if (conversation.isOnline) Color.Green else Color.Gray
+ )
+ )
+
+ Spacer(modifier = Modifier.width(8.dp))
+
+ // Last message content
+ Text(
+ text = conversation.lastMessage ?: "No messages yet",
+ style = MaterialTheme.typography.bodyMedium,
+ color = MaterialTheme.colorScheme.onSurfaceVariant,
+ maxLines = 1,
+ overflow = TextOverflow.Ellipsis,
+ modifier = Modifier.weight(1f)
+ )
+ }
+
+ //unread count badge
+ if (conversation.unreadCount > 0) {
+ Box(
+ modifier = Modifier
+ .size(20.dp)
+ .clip(CircleShape)
+ .background(MaterialTheme.colorScheme.primary),
+ contentAlignment = Alignment.Center
+ ) {
+ Text(
+ text = conversation.unreadCount.toString(),
+ color = MaterialTheme.colorScheme.onPrimary,
+ style = MaterialTheme.typography.labelSmall
+ )
+ }
+ }
+ }
+ }
+ }
+}
+
+@Composable
+fun EmptyConversationsView() {
+ Column(
+ modifier = Modifier
+ .fillMaxSize()
+ .padding(16.dp),
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.Center
+ ) {
+ Icon(
+ imageVector = Icons.Default.Chat,
+ contentDescription = null,
+ modifier = Modifier.size(72.dp),
+ tint = MaterialTheme.colorScheme.primary
+ )
+
+ Spacer(modifier = Modifier.height(16.dp))
+
+ Text(
+ text = "No Conversations Yet",
+ style = MaterialTheme.typography.headlineSmall
+ )
+
+ Spacer(modifier = Modifier.height(8.dp))
+
+ Text(
+ text = "Connect with users on the network to start chatting",
+ style = MaterialTheme.typography.bodyMedium,
+ color = MaterialTheme.colorScheme.onSurfaceVariant,
+ modifier = Modifier.padding(horizontal = 32.dp)
+ )
+ }
+}
+
+@Composable
+fun ErrorView(
+ errorMessage: String,
+ onRetry: () -> Unit
+) {
+ Column(
+ modifier = Modifier
+ .fillMaxSize()
+ .padding(16.dp),
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.Center
+ ) {
+ Icon(
+ imageVector = Icons.Default.Error,
+ contentDescription = null,
+ modifier = Modifier.size(72.dp),
+ tint = MaterialTheme.colorScheme.error
+ )
+
+ Spacer(modifier = Modifier.height(16.dp))
+
+ Text(
+ text = "Error Loading Conversations",
+ style = MaterialTheme.typography.headlineSmall
+ )
+
+ Spacer(modifier = Modifier.height(8.dp))
+
+ Text(
+ text = errorMessage,
+ style = MaterialTheme.typography.bodyMedium,
+ color = MaterialTheme.colorScheme.onSurfaceVariant,
+ modifier = Modifier.padding(horizontal = 32.dp)
+ )
+
+ Spacer(modifier = Modifier.height(16.dp))
+
+ Button(
+ onClick = onRetry,
+ contentPadding = PaddingValues(horizontal = 16.dp)
+ ) {
+ Icon(
+ imageVector = Icons.Default.Refresh,
+ contentDescription = null
+ )
+ Spacer(modifier = Modifier.width(8.dp))
+ Text("Retry")
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/ui/viewmodels/ChatScreenViewModel.kt b/app/src/main/java/com/greybox/projectmesh/messaging/ui/viewmodels/ChatScreenViewModel.kt
new file mode 100644
index 00000000..af1621b5
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/ui/viewmodels/ChatScreenViewModel.kt
@@ -0,0 +1,340 @@
+package com.greybox.projectmesh.messaging.ui.viewmodels
+
+import android.net.Uri
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.greybox.projectmesh.GlobalApp
+import com.greybox.projectmesh.db.MeshDatabase
+import com.greybox.projectmesh.messaging.data.entities.Message
+import com.greybox.projectmesh.messaging.ui.models.ChatScreenModel
+import com.greybox.projectmesh.testing.TestDeviceService
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import org.kodein.di.DI
+import com.greybox.projectmesh.server.AppServer
+import com.greybox.projectmesh.server.AppServer.OutgoingTransferInfo
+import com.ustadmobile.meshrabiya.ext.addressToDotNotation
+import com.ustadmobile.meshrabiya.ext.requireAddressAsInt
+import com.greybox.projectmesh.messaging.utils.ConversationUtils
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.kodein.di.instance
+import java.net.InetAddress
+import com.greybox.projectmesh.messaging.repository.ConversationRepository
+import com.greybox.projectmesh.user.UserEntity
+import android.content.SharedPreferences
+import androidx.lifecycle.SavedStateHandle
+import com.greybox.projectmesh.DeviceStatusManager
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.withTimeoutOrNull
+import timber.log.Timber
+import java.net.URI
+
+class ChatScreenViewModel(
+ di: DI,
+ savedStateHandle: SavedStateHandle
+) : ViewModel() {
+ private val virtualAddress: InetAddress = savedStateHandle.get("virtualAddress")!!
+
+ // _uiState will be updated whenever there is a change in the UI state
+ private val ipStr: String = virtualAddress.hostAddress
+
+ //get conversation id
+ private val passedConversationId = savedStateHandle.get("conversationId")
+
+ //Get User info
+ private val userEntity = runBlocking {
+ GlobalApp.GlobalUserRepo.userRepository.getUserByIp(ipStr)
+ }
+
+ // Use the retrieved user name (fallback to "Unknown" if no user is found)
+ private val deviceName = userEntity?.name ?: "Unknown"
+
+ private val sharedPrefs: SharedPreferences by di.instance(tag = "settings")
+ private val localUuid = sharedPrefs.getString("UUID", null) ?: "local-user"
+
+ private val userUuid: String = when {
+ passedConversationId != null && passedConversationId.contains("-") -> {
+ // Extract the UUID that's not the local UUID
+ val uuids = passedConversationId.split("-")
+ uuids.find { it != localUuid } ?: "unknown-${virtualAddress.hostAddress}"
+ }
+ // Otherwise use the standard logic
+ TestDeviceService.isOnlineTestDevice(virtualAddress) -> "test-device-uuid"
+ ipStr == TestDeviceService.TEST_DEVICE_IP_OFFLINE ||
+ userEntity?.name == TestDeviceService.TEST_DEVICE_NAME_OFFLINE -> "offline-test-device-uuid"
+ else -> userEntity?.uuid ?: "unknown-${virtualAddress.hostAddress}"
+ }
+
+ private val savedConversationId = savedStateHandle.get("conversationId")
+ //Timber.tag("ChatDebug").d("GOT CONVERSATION ID FROM SAVED STATE: $savedConversationId")
+
+ private val conversationId = passedConversationId ?:
+ ConversationUtils.createConversationId(localUuid, userUuid)
+
+ private val chatName = savedConversationId ?: conversationId
+ //Timber.tag("ChatDebug").d("USING CHAT NAME: $chatName (saved: $savedConversationId,
+ // generated:
+ // $conversationId)")
+
+
+
+ private val addressDotNotation = virtualAddress.requireAddressAsInt().addressToDotNotation()
+
+ private val conversationRepository: ConversationRepository by di.instance()
+
+
+ private val _uiState = MutableStateFlow(
+ ChatScreenModel(
+ deviceName = deviceName,
+ virtualAddress = virtualAddress
+ )
+ )
+
+ // uiState is a read-only property that shows the current UI state
+ val uiState: Flow = _uiState.asStateFlow()
+
+ // di is used to get the AndroidVirtualNode instance
+ private val db: MeshDatabase by di.instance()
+
+ private val appServer: AppServer by di.instance()
+
+ private val _deviceOnlineStatus = MutableStateFlow(false)
+ val deviceOnlineStatus: StateFlow = _deviceOnlineStatus.asStateFlow()
+
+ // launch a coroutine
+ init {
+
+ val savedConversationId = savedStateHandle.get("conversationId")
+
+ // If we have a conversation ID from navigation, use it directly
+ val effectiveChatName = if (savedConversationId != null) {
+ Timber.tag("ChatDebug").d("USING SAVED CONVERSATION ID: $savedConversationId INSTEAD OF GENERATED: $chatName")
+ savedConversationId
+ } else {
+ chatName
+ }
+
+ viewModelScope.launch {
+ // Debug logs
+ Timber.tag("ChatDebug").d("Will query messages with chatName: $chatName")
+ Timber.tag("ChatDebug").d("Using Conversation ID for messages: $conversationId")
+ Timber.tag("ChatDebug").d("User UUID: $userUuid")
+
+ //check database content in background
+ withContext(Dispatchers.IO) {
+ val allMessages = db.messageDao().getAll()
+ Timber.d("ChatDebug", "All messages in database: ${allMessages.size}")
+ for (msg in allMessages) {
+ Timber.tag("ChatDebug").d(
+ "Message: id=${msg.id}, chat=${msg.chat}, content=${msg.content}, sender=${msg.sender}"
+ )
+ }
+ }
+
+ //determine which flow to collect from
+ val isTestDevice =
+ (userUuid == "test-device-uuid" || userUuid == "offline-test-device-uuid")
+
+ //load messages synchronously for offline access
+ val initialChatName = chatName // Use consistent chat name
+
+ try {
+ // Get messages immediately without waiting for Flow
+ val initialMessages = withContext(Dispatchers.IO) {
+ // We'll need to add this method to MessageDao in Step 3
+ db.messageDao().getChatMessagesSync(chatName)
+ }
+
+ // Update UI immediately with initial messages
+ if (initialMessages.isNotEmpty()) {
+ _uiState.update { prev ->
+ prev.copy(allChatMessages = initialMessages)
+ }
+ Timber.tag("ChatDebug").d("IMMEDIATELY LOADED ${initialMessages.size} " +
+ "MESSAGES FOR OFFLINE ACCESS")
+ } else {
+ Timber.tag("ChatDebug").d("NO INITIAL MESSAGES FOUND FOR CHAT: $chatName")
+ }
+
+ } catch (e: Exception) {
+ Timber.e("ChatDebug", "ERROR LOADING INITIAL MESSAGES: ${e.message}", e)
+ }
+
+ val messagesFlow = if (isTestDevice) {
+ val testDeviceName = when (userUuid) {
+ "test-device-uuid" -> TestDeviceService.TEST_DEVICE_NAME
+ "offline-test-device-uuid" -> TestDeviceService.TEST_DEVICE_NAME_OFFLINE
+ else -> null
+ }
+
+ if (testDeviceName != null) {
+ Timber.tag("ChatDebug").d("Using multi-name query with: [$chatName,$testDeviceName]")
+ db.messageDao().getChatMessagesFlowMultipleNames(
+ listOf(chatName, testDeviceName)
+ )
+ } else {
+ db.messageDao().getChatMessagesFlow(chatName)
+ }
+ } else {
+ db.messageDao().getChatMessagesFlow(chatName)
+ }
+
+ //collect messages from the chosen flow
+ messagesFlow.collect { newChatMessages ->
+ Timber.tag("ChatDebug").d("Received ${newChatMessages.size} messages")
+ _uiState.update { prev ->
+ prev.copy(allChatMessages = newChatMessages)
+ }
+ }
+ }
+
+ viewModelScope.launch {
+ // If this is a real device (not placeholder address)
+ if (virtualAddress.hostAddress != "0.0.0.0" &&
+ virtualAddress.hostAddress != TestDeviceService.TEST_DEVICE_IP_OFFLINE
+ ) {
+ DeviceStatusManager.deviceStatusMap.collect { statusMap ->
+ val ipAddress = virtualAddress.hostAddress
+ val isOnline = statusMap[ipAddress] ?: false
+
+ // Only update if status changed
+ if (_deviceOnlineStatus.value != isOnline) {
+ Timber.tag("ChatDebug").d("Device status changed: $ipAddress is now ${if (isOnline) "online" else "offline"}")
+ _deviceOnlineStatus.value = isOnline
+
+ if (isOnline) {
+ Timber.d("ChatDebug", "Device came back online - refreshing message history")
+ // Force refresh messages from database
+ withContext(Dispatchers.IO) {
+ val refreshedMessages = db.messageDao().getChatMessagesSync(chatName)
+ _uiState.update { prev ->
+ prev.copy(
+ allChatMessages = refreshedMessages,
+ offlineWarning = null // Clear offline warning
+ )
+ }
+ }
+ } else {
+ // Update the UI state with offline warning
+ _uiState.update { prev ->
+ prev.copy(
+ offlineWarning = "Device appears to be offline. Messages will be saved locally."
+ )
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private suspend fun markConversationAsRead() {
+ try {
+ if (userEntity != null) {
+ //Create a convo id using both UUIDs
+ val conversationId =
+ ConversationUtils.createConversationId(localUuid, userEntity.uuid)
+
+ //Mark this conversation as read
+ conversationRepository.markAsRead(conversationId)
+ Timber.tag("ChatScreenViewModel").d("Marked conversation as read: $conversationId")
+ }
+ } catch (e: Exception) {
+ Timber.tag("ChatScreenViewModel").e(e,"Error marking conversation as read")
+ }
+ }
+
+
+ fun sendChatMessage(
+ virtualAddress: InetAddress,
+ message: String,
+ file: URI?
+ ) {//add file field here
+ val ipAddress = virtualAddress.hostAddress
+ val sendTime: Long = System.currentTimeMillis()
+
+ //check if device is online first
+ val isOnline = DeviceStatusManager.isDeviceOnline(ipAddress)
+
+ //use same conversationid as chat name
+ val messageEntity = Message(0, sendTime, message, "Me", chatName, file)
+
+ Timber.tag("ChatDebug").d("Sending message to chat: $chatName")
+ viewModelScope.launch {
+ //save to local database
+ db.messageDao().addMessage(messageEntity)
+
+ //update convo with the new message
+ if (userEntity != null) {
+ try {
+ //get or create conversation
+ val remoteUser = UserEntity(
+ uuid = userUuid,
+ name = userEntity.name,
+ address = userEntity.address
+ )
+
+ val conversation = conversationRepository.getOrCreateConversation(
+ localUuid = localUuid,
+ remoteUser = remoteUser
+ )
+
+ //update conversation with the message
+ conversationRepository.updateWithMessage(
+ conversationId = conversation.id,
+ message = messageEntity
+ )
+
+ Timber.tag("ChatScreenViewModel").d("Updated conversation with sent message")
+ } catch (e: Exception) {
+ Timber.tag("ChatScreenViewModel").e(e,"Failed to update conversation with sent message")
+ }
+ }
+
+ if (isOnline) {
+ try {
+ // Use withContext to ensure network operations run on IO thread
+ val delivered = withContext(Dispatchers.IO) {
+ // Try with a timeout to prevent blocking
+ withTimeoutOrNull(5000) {
+ appServer.sendChatMessageWithStatus(virtualAddress, sendTime, message, file)
+ } ?: false
+ }
+
+ // Update UI based on delivery status
+ if (!delivered) {
+ Timber.tag("ChatDebug").d("Message delivery failed")
+ _uiState.update { prev ->
+ prev.copy(offlineWarning = "Message delivery failed. Device may be offline.")
+ }
+ // Force device status verification
+ DeviceStatusManager.verifyDeviceStatus(ipAddress)
+ } else {
+ Timber.tag("ChatDebug").d("Message delivered successfully")
+ }
+ } catch (e: Exception) {
+ Timber.tag("ChatScreenViewModel").e(e, "Error sending message: ${e.message}")
+ _uiState.update { prev ->
+ prev.copy(offlineWarning = "Error sending message: ${e.message}")
+ }
+ }
+ } else {
+ Timber.tag("ChatScreenViewModel").d("Device $ipAddress appears to be offline, " +
+ "message saved locally only")
+ _uiState.update { prev ->
+ prev.copy(offlineWarning = "Device appears to be offline. Message saved locally only.")
+ }
+ }
+ }
+ }
+
+ //handles outgoing file transfer to fix unresolved reference error crash
+ fun addOutgoingTransfer(fileUri: Uri, toAddress: InetAddress): OutgoingTransferInfo {
+ return appServer.addOutgoingTransfer(fileUri, toAddress)
+ }
+}
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/ui/viewmodels/ConversationsHomeScreenViewModel.kt b/app/src/main/java/com/greybox/projectmesh/messaging/ui/viewmodels/ConversationsHomeScreenViewModel.kt
new file mode 100644
index 00000000..0069fdae
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/ui/viewmodels/ConversationsHomeScreenViewModel.kt
@@ -0,0 +1,158 @@
+package com.greybox.projectmesh.messaging.ui.viewmodels
+
+import android.content.SharedPreferences
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.greybox.projectmesh.DeviceStatusManager
+import com.greybox.projectmesh.messaging.repository.ConversationRepository
+import com.greybox.projectmesh.messaging.ui.models.ConversationsHomeScreenModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import org.kodein.di.DI
+import org.kodein.di.instance
+import timber.log.Timber
+
+class ConversationsHomeScreenViewModel(
+ di: DI
+) : ViewModel() {
+
+ //keep track of UI state
+ private val _uiState = MutableStateFlow(ConversationsHomeScreenModel(isLoading = true))
+ val uiState: Flow = _uiState.asStateFlow()
+
+ //get repository instances
+ private val conversationRepository: ConversationRepository by di.instance()
+
+ // Get access to SharedPreferences for the local UUID
+ private val sharedPrefs: SharedPreferences by di.instance(tag = "settings")
+
+ init {
+ loadConversations()
+
+ viewModelScope.launch {
+ DeviceStatusManager.deviceStatusMap
+ .collect { deviceStatusMap ->
+ // Process immediately without debouncing
+ updateConversationStatuses(deviceStatusMap)
+ }
+ }
+ }
+
+ //Update conversations Status based on device status
+ private fun updateConversationStatuses(deviceStatusMap: Map) {
+ viewModelScope.launch(Dispatchers.IO) { // Use IO dispatcher for database operations
+ try {
+ // Get current conversations once
+ val currentConversations = _uiState.value.conversations
+
+ // Create a list to track conversations needing updates
+ val conversationsToUpdate = mutableListOf>()
+
+ // Check which conversations need updates
+ currentConversations.forEach { conversation ->
+ conversation.userAddress?.let { ipAddress ->
+ val isOnline = deviceStatusMap[ipAddress] ?: false
+ if (conversation.isOnline != isOnline) {
+ conversationsToUpdate.add(Pair(conversation.userUuid, isOnline))
+ }
+ }
+ }
+
+ // Batch update all needed conversations
+ conversationsToUpdate.forEach { (userUuid, isOnline) ->
+ // Update conversation status in database
+ conversationRepository.updateUserStatus(
+ userUuid = userUuid,
+ isOnline = isOnline,
+ userAddress = if (isOnline)
+ currentConversations.find { it.userUuid == userUuid }?.userAddress
+ else null
+ )
+
+ Timber.tag("ConversationsViewModel").d(
+ "Updated conversation status for ${currentConversations.find { it.userUuid == userUuid }?.userName}: online=$isOnline")
+ }
+
+ // If we made any updates, force a refresh of the list
+ if (conversationsToUpdate.isNotEmpty()) {
+ refreshConversations()
+ }
+ } catch (e: Exception) {
+ Timber.tag("ConversationsViewModel").e(e,"Error updating conversation statuses")
+ }
+ }
+ }
+
+
+ private fun loadConversations() {
+ viewModelScope.launch {
+ try {
+ //start with loading state
+ _uiState.update { it.copy (isLoading = true, error = null )}
+
+ //get local device id
+ val localUuid = sharedPrefs.getString("UUID", null) ?: "local-user"
+ Timber.tag("ConversationsViewModel").d("Local UUID: $localUuid")
+
+ //collect conversations from repository
+ conversationRepository.getAllConversations().collect { conversations ->
+ Timber.tag("ConversationsViewModel").d("Loaded ${conversations.size} " +
+ "conversations")
+
+ //filter out conversations with self
+ val filteredConversations = conversations.filter { conversation ->
+ conversation.userUuid != localUuid
+ }
+
+ conversations.forEach { conversation ->
+ Timber.tag("ConversationsViewModel").d("Conversation: ID=${conversation
+ .id}, UserUUID=${conversation.userUuid}, Name=${conversation.userName}")
+ }
+
+ Timber.tag("ConversationsViewModel").d("Filtering out conversations with UUID:$localUuid")
+
+ Timber.tag("ConversationsViewModel").d("After filtering self:${filteredConversations.size} conversations")
+
+
+ //update the UI state with the conversations
+ _uiState.update {
+ it.copy(
+ isLoading = false,
+ conversations = filteredConversations,
+ error = null
+ )
+ }
+ }
+ }catch (e: Exception) {
+ Timber.tag("ConversationsViewModel").e(e,"Error loading conversations")
+
+ _uiState.update {
+ it.copy (
+ isLoading = false,
+ error = "Failed to load conversations: ${e.message}"
+ )
+ }
+ }
+ }
+ }
+
+ //function to refresh conversations manually
+ fun refreshConversations(){
+ loadConversations()
+ }
+
+ //Function to mark a conversation as read
+ fun markConversationAsRead(conversationId: String) {
+ viewModelScope.launch {
+ try {
+ conversationRepository.markAsRead(conversationId)
+ } catch (e: Exception) {
+ Timber.tag("ConversationsViewModel").e(e, "Error marking conversation as read")
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/utils/ConversationUtils.kt b/app/src/main/java/com/greybox/projectmesh/messaging/utils/ConversationUtils.kt
new file mode 100644
index 00000000..8c1054f4
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/utils/ConversationUtils.kt
@@ -0,0 +1,33 @@
+package com.greybox.projectmesh.messaging.utils
+
+import com.greybox.projectmesh.testing.TestDeviceService
+
+/**
+ * Centralized utility class for conversation-related operations.
+ * This ensures consistent conversation ID generation across the application.
+ */
+
+object ConversationUtils {
+ /**
+ * Creates a consistent conversation ID from two UUIDs.
+ * This method ensures that the same conversation ID is generated
+ * regardless of which user initiates the conversation.
+ *
+ * @param uuid1 The UUID of the first user
+ * @param uuid2 The UUID of the second user
+ * @return A standardized conversation ID
+ */
+
+ fun createConversationId(uuid1: String, uuid2: String): String {
+ //special cases for test devices
+ if (uuid2 == "test-device-uuid") {
+ return "local-user-test-device-uuid"
+ }
+ if (uuid2 == "offline-test-device-uuid") {
+ return "local-user-offline-test-device-uuid"
+ }
+
+ //sort UUIDs to ensure the same ID is generated regardless of order
+ return listOf(uuid1, uuid2).sorted().joinToString("-")
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/utils/Logger.kt b/app/src/main/java/com/greybox/projectmesh/messaging/utils/Logger.kt
new file mode 100644
index 00000000..804c5174
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/utils/Logger.kt
@@ -0,0 +1,50 @@
+package com.greybox.projectmesh.utils
+
+import timber.log.Timber
+
+/**
+ * Centralized logging utility for the app.
+ * Provides consistent logging with standardized tags and can be disabled in production.
+ */
+
+object Logger {
+ private const val LOGGING_ENABLED = true
+ private const val TAG_PREFIX = "MeshChat_"
+
+ fun d(tag: String, message: String) {
+ if (LOGGING_ENABLED) {
+ Timber.tag("$TAG_PREFIX$tag").d(message)
+ }
+ }
+
+ fun i(tag: String, message: String) {
+ if (LOGGING_ENABLED) {
+ Timber.tag("$TAG_PREFIX$tag").i(message)
+ }
+ }
+
+ fun w(tag: String, message: String) {
+ if (LOGGING_ENABLED) {
+ Timber.tag("$TAG_PREFIX$tag").w(message)
+ }
+ }
+
+ fun e(tag: String, message: String, throwable: Throwable? = null) {
+ if (LOGGING_ENABLED) {
+ if (throwable != null) {
+ Timber.tag("$TAG_PREFIX$tag").e(throwable, message)
+ } else {
+ Timber.tag("$TAG_PREFIX$tag").e(message)
+ }
+ }
+ }
+
+ // Log important events that should be visible even in production
+ fun critical(tag: String, message: String, throwable: Throwable? = null) {
+ if (throwable != null) {
+ Timber.tag("$TAG_PREFIX${tag}_CRITICAL").e(throwable, message)
+ } else {
+ Timber.tag("$TAG_PREFIX${tag}_CRITICAL").e(message)
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/utils/MessageMigrationUtils.kt b/app/src/main/java/com/greybox/projectmesh/messaging/utils/MessageMigrationUtils.kt
new file mode 100644
index 00000000..708df0ab
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/utils/MessageMigrationUtils.kt
@@ -0,0 +1,106 @@
+//script to help migrate existing messages
+package com.greybox.projectmesh.messaging.utils
+
+import com.greybox.projectmesh.GlobalApp
+import com.greybox.projectmesh.db.MeshDatabase
+import com.greybox.projectmesh.testing.TestDeviceService
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.kodein.di.DI
+import org.kodein.di.DIAware
+import org.kodein.di.instance
+import timber.log.Timber
+
+class MessageMigrationUtils(
+ override val di: DI
+): DIAware {
+ private val db: MeshDatabase by di.instance()
+
+ /**
+ * Migrates existing messages to use in converstion IDs as chatNames
+ */
+
+ suspend fun migrateMessagesToChatIds() {
+ withContext(Dispatchers.IO){
+ try {
+ //get all messages by id
+ val messages = db.messageDao().getAll()
+ Timber.tag("MessageMigration").d("Found ${messages.size} messages to check for " +
+ "migration")
+
+ //group messages by their current chat names
+ val messagesByChat = messages.groupBy { it.chat }
+
+ //process each chat group
+ messagesByChat.forEach { (chatName, messagesInChat) ->
+ //skip messages that already appear by using convo id format
+ if (chatName.contains("-") && (chatName.count { it == '-' } >= 1)){
+ Timber.tag("MessageMigration").d("Chat $chatName already appears to use conversation ID format")
+ return@forEach
+ }
+
+ //determine the Uuid for this chat
+ val userUuid = when (chatName) {
+ TestDeviceService.TEST_DEVICE_NAME -> "test-device-uuid"
+ TestDeviceService.TEST_DEVICE_NAME_OFFLINE -> "offline-test-device-uuid"
+ else -> {
+ try {
+ //try to find users by checking connected users first
+ val allUsers = GlobalApp.GlobalUserRepo.userRepository.getAllUsers()
+ val matchingUser = allUsers.find { user -> user.name == chatName }
+
+ if (matchingUser != null) {
+ matchingUser.uuid
+ } else {
+ // If not found in connected users, create a placeholder UUID
+ "unknown-${chatName}"
+ }
+ }catch (e: Exception) {
+ Timber.tag(
+ "MessageMigration").e(e,
+ "Error finding user for chat $chatName"
+ )
+ "unknown-${chatName}"
+ }
+ }
+ }
+
+ //create the new conversation ID
+ val localUuid = GlobalApp.GlobalUserRepo.prefs.getString("UUID", null) ?: "local-user"
+ val newChatName = createConversationId(localUuid, userUuid)
+
+ if (chatName != newChatName) {
+ Timber.tag("MessageMigration").d("Migrating ${messagesInChat.size} messages from '$chatName' to '$newChatName'")
+
+ //Create new messages with the updated chat name
+ val updatedMessages = messagesInChat.map {
+ it.copy (chat = newChatName)
+ }
+
+ //Delete old messages and insert updated ones
+ db.messageDao().deleteAll(messagesInChat)
+ for (message in updatedMessages) {
+ db.messageDao().addMessage(message)
+ }
+
+ Timber.tag("MessageMigration").d("Successfully migrated messages for chat" +
+ " 'chatName'")
+ }
+ }
+ }catch (e:Exception){
+ Timber.tag("MessageMigration").e(e,"Error during message migration")
+ }
+ }
+ }
+
+ private fun createConversationId(uuid1: String, uuid2: String): String {
+ // Special cases for test devices
+ if (uuid2 == "test-device-uuid") {
+ return "local-user-test-device-uuid"
+ }
+ if (uuid2 == "offline-test-device-uuid") {
+ return "local-user-offline-test-device-uuid"
+ }
+ return listOf(uuid1, uuid2).sorted().joinToString("-")
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/messaging/utils/MessageUtils.kt b/app/src/main/java/com/greybox/projectmesh/messaging/utils/MessageUtils.kt
new file mode 100644
index 00000000..af2d2027
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/messaging/utils/MessageUtils.kt
@@ -0,0 +1,13 @@
+package com.greybox.projectmesh.messaging.utils
+
+object MessageUtils {
+ fun formatTimestamp(timestamp: Long): String {
+ //Adding timestamp formatting logic
+ return java.text.SimpleDateFormat("HH:mm").format(timestamp)
+ }
+
+ fun generateChatId(sender: String, receiver: String): String {
+ //Create a consistent chat ID for two users
+ return listOf(sender, receiver).sorted().joinToString("-")
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/navigation/BottomNavHost.kt b/app/src/main/java/com/greybox/projectmesh/navigation/BottomNavHost.kt
index 2f200088..e047a166 100644
--- a/app/src/main/java/com/greybox/projectmesh/navigation/BottomNavHost.kt
+++ b/app/src/main/java/com/greybox/projectmesh/navigation/BottomNavHost.kt
@@ -1,37 +1,21 @@
package com.greybox.projectmesh.navigation
-import android.util.Log
-import androidx.activity.ComponentActivity
-import androidx.compose.foundation.layout.padding
+import android.content.pm.ApplicationInfo
import androidx.compose.runtime.Composable
import androidx.navigation.NavGraph.Companion.findStartDestination
import androidx.navigation.NavHostController
import androidx.compose.material3.*
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Modifier
+import androidx.compose.runtime.remember
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.stringResource
-import androidx.lifecycle.viewmodel.compose.viewModel
-import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.sp
import androidx.navigation.compose.rememberNavController
import com.greybox.projectmesh.R
-import com.greybox.projectmesh.ui.theme.AppTheme
-import com.greybox.projectmesh.viewModel.SharedUriViewModel
-import com.greybox.projectmesh.views.ChatScreen
-import com.greybox.projectmesh.views.HomeScreen
-import com.greybox.projectmesh.views.NetworkScreen
-import com.greybox.projectmesh.views.PingScreen
-import com.greybox.projectmesh.views.ReceiveScreen
-import com.greybox.projectmesh.views.SelectDestNodeScreen
-import com.greybox.projectmesh.views.SendScreen
-import com.greybox.projectmesh.views.SettingsScreen
-import org.kodein.di.DI
-import org.kodein.di.compose.withDI
-import java.net.InetAddress
+import org.kodein.di.android.BuildConfig
data class NavigationItem(
val route: String,
@@ -39,113 +23,49 @@ data class NavigationItem(
val icon: ImageVector,
)
+//Preview is to show the bottom navigation bar in the preview and notice what it looks like
+@Preview(showBackground = true)
@Composable
-fun BottomNavApp(di: DI,
- startDestination: String,
- onThemeChange: (AppTheme) -> Unit,
- onLanguageChange: (String) -> Unit,
- onNavigateToScreen: (String) -> Unit,
- onRestartServer: () -> Unit,
- onDeviceNameChange: (String) -> Unit,
- deviceName: String,
- onAutoFinishChange: (Boolean) -> Unit,
- onSaveToFolderChange: (String) -> Unit
-) = withDI(di)
-{
+fun BottomNavigationBarPreview() {
val navController = rememberNavController()
- // Observe the current route directly through the back stack entry
- val currentRoute = navController.currentBackStackEntryFlow.collectAsState(initial = null)
- LaunchedEffect(currentRoute.value?.destination?.route) {
- if(currentRoute.value?.destination?.route == BottomNavItem.Settings.route){
- currentRoute.value?.destination?.route?.let { route ->
- onNavigateToScreen(route)
- }
- }
- }
- Scaffold(
- bottomBar = { BottomNavigationBar(navController) }
- ){ innerPadding ->
- NavHost(navController, startDestination = startDestination, Modifier.padding(innerPadding))
- {
- composable(BottomNavItem.Home.route) {
- HomeScreen(deviceName = deviceName) }
- composable(BottomNavItem.Network.route) { NetworkScreen(
- onClickNetworkNode = { ip ->
- navController.navigate("chatScreen/${ip}")
- }
- ) }
- composable("chatScreen/{ip}"){ entry ->
- val ip = entry.arguments?.getString("ip")
- ?: throw IllegalArgumentException("Invalid address")
- ChatScreen(
- virtualAddress = InetAddress.getByName(ip),
- onClickButton = {
- navController.navigate("pingScreen/${ip}")
- }
- )
- }
- composable("pingScreen/{ip}"){ entry ->
- val ip = entry.arguments?.getString("ip")
- ?: throw IllegalArgumentException("Invalid address")
- PingScreen(
- virtualAddress = InetAddress.getByName(ip)
- )
- }
- composable(BottomNavItem.Send.route) {
- val activity = LocalContext.current as ComponentActivity
- val sharedUrisViewModel: SharedUriViewModel = viewModel(activity)
- SendScreen(
- onSwitchToSelectDestNode = { uris ->
- Log.d("uri_track_nav_send", "size: " + uris.size.toString())
- Log.d("uri_track_nav_send", "List: $uris")
- sharedUrisViewModel.setUris(uris)
- navController.navigate("selectDestNode")
- }
- )
- }
- composable("selectDestNode"){
- val activity = LocalContext.current as ComponentActivity
- val sharedUrisViewModel: SharedUriViewModel = viewModel(activity)
- val sendUris by sharedUrisViewModel.uris.collectAsState()
- Log.d("uri_track_nav_selectDestNode", "size: " + sendUris.size.toString())
- Log.d("uri_track_nav_selectDestNode", "List: $sendUris")
- SelectDestNodeScreen(
- uris = sendUris,
- popBackWhenDone = {navController.popBackStack()},
- )
- }
- composable(BottomNavItem.Receive.route) { ReceiveScreen(
- onAutoFinishChange = onAutoFinishChange
- ) }
- composable(BottomNavItem.Settings.route) {
- SettingsScreen(
- onThemeChange = onThemeChange,
- onLanguageChange = onLanguageChange,
- onRestartServer = onRestartServer,
- onDeviceNameChange = onDeviceNameChange,
- onAutoFinishChange = onAutoFinishChange,
- onSaveToFolderChange = onSaveToFolderChange
- )
- }
- }
- }
+ BottomNavigationBar(navController = navController)
}
@Composable
fun BottomNavigationBar(navController: NavHostController) {
- val items = listOf(
- NavigationItem(BottomNavItem.Home.route, stringResource(id = R.string.home), BottomNavItem.Home.icon),
- NavigationItem(BottomNavItem.Network.route, stringResource(id = R.string.network), BottomNavItem.Network.icon),
- NavigationItem(BottomNavItem.Send.route, stringResource(id = R.string.send), BottomNavItem.Send.icon),
- NavigationItem(BottomNavItem.Receive.route, stringResource(id = R.string.receive), BottomNavItem.Receive.icon),
- NavigationItem(BottomNavItem.Settings.route, stringResource(id = R.string.settings), BottomNavItem.Settings.icon)
- )
+ val context = LocalContext.current
+ val isDebuggable = remember {
+ (context.applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0
+ }
+ val items = buildList {
+ add(NavigationItem(BottomNavItem.Home.route, stringResource(id = R.string.home), BottomNavItem.Home.icon))
+ add(NavigationItem(BottomNavItem.Network.route, stringResource(id = R.string.network), BottomNavItem.Network.icon))
+ add(NavigationItem(BottomNavItem.Send.route, stringResource(id = R.string.send), BottomNavItem.Send.icon))
+ add(NavigationItem(BottomNavItem.Receive.route, stringResource(id = R.string.receive), BottomNavItem.Receive.icon))
+ add(NavigationItem(BottomNavItem.Chat.route, stringResource(id = R.string.chat), BottomNavItem.Chat.icon))
+
+ // ✅ Only add the log tab if it's a DEBUG build
+ if (isDebuggable) {
+ add(NavigationItem(BottomNavItem.Log.route, stringResource(id = R.string.log), BottomNavItem.Log.icon))
+ }
+
+ add(NavigationItem(BottomNavItem.Settings.route, stringResource(id = R.string.settings), BottomNavItem.Settings.icon))
+ }
NavigationBar {
val currentRoute = navController.currentDestination?.route
items.forEach { item ->
NavigationBarItem(
icon = { Icon(item.icon, contentDescription = item.label) },
- label = { Text(item.label) },
+ //Modify label Sizes to fit the screen of multiple devices
+ label = {
+ Text(
+ item.label,
+ fontSize = 10.5.sp,
+ maxLines = 1,
+ softWrap = false,
+ overflow = TextOverflow.Clip
+ )
+ },
selected = currentRoute == item.route,
onClick = {
navController.navigate(item.route) {
@@ -158,8 +78,9 @@ fun BottomNavigationBar(navController: NavHostController) {
// Avoid multiple copies of the same destination when reselecting the same item
launchSingleTop = true
}
- }
+ },
+
)
}
}
-}
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/navigation/BottomNavItem.kt b/app/src/main/java/com/greybox/projectmesh/navigation/BottomNavItem.kt
index 1396be76..83e8b935 100644
--- a/app/src/main/java/com/greybox/projectmesh/navigation/BottomNavItem.kt
+++ b/app/src/main/java/com/greybox/projectmesh/navigation/BottomNavItem.kt
@@ -11,5 +11,7 @@ sealed class BottomNavItem(val route: String, val title: String, val icon: Image
data object Network : BottomNavItem("network", "Network", Icons.Default.Wifi)
data object Send : BottomNavItem("send", "Send", Icons.AutoMirrored.Filled.Send)
data object Receive : BottomNavItem("receive", "Receive", Icons.Default.Download)
+ data object Log: BottomNavItem("log", "Log", Icons.Default.History)
data object Settings : BottomNavItem("settings", "Settings", Icons.Default.Settings)
+ data object Chat : BottomNavItem("chat", "Chat", Icons.Default.ChatBubble)
}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/server/AppServer.kt b/app/src/main/java/com/greybox/projectmesh/server/AppServer.kt
index af912e24..b6a03d12 100644
--- a/app/src/main/java/com/greybox/projectmesh/server/AppServer.kt
+++ b/app/src/main/java/com/greybox/projectmesh/server/AppServer.kt
@@ -1,14 +1,24 @@
package com.greybox.projectmesh.server
+import android.app.NotificationManager
+import android.app.PendingIntent
import android.content.Context
+import android.content.Intent
import android.content.SharedPreferences
import android.net.Uri
import android.os.Build
import android.util.Log
+import androidx.core.app.NotificationCompat
+import com.google.gson.Gson
+import com.greybox.projectmesh.DeviceStatusManager
import com.greybox.projectmesh.GlobalApp
+import com.greybox.projectmesh.MainActivity
+import com.greybox.projectmesh.R
import com.greybox.projectmesh.db.MeshDatabase
-import com.greybox.projectmesh.db.entities.Message
+import com.greybox.projectmesh.messaging.data.entities.Message
+import com.greybox.projectmesh.messaging.network.MessageNetworkHandler
import com.greybox.projectmesh.extension.updateItem
+import com.greybox.projectmesh.testing.TestDeviceService
import com.ustadmobile.meshrabiya.ext.copyToWithProgressCallback
import com.ustadmobile.meshrabiya.util.FileSerializer
import com.ustadmobile.meshrabiya.util.InetAddressSerializer
@@ -37,13 +47,22 @@ import java.net.InetAddress
import java.net.URLEncoder
import java.util.concurrent.atomic.AtomicInteger
import com.greybox.projectmesh.extension.getUriNameAndSize
+import com.greybox.projectmesh.messaging.data.entities.JSONSchema
+import com.greybox.projectmesh.user.UserEntity
+import com.greybox.projectmesh.user.UserRepository
import org.kodein.di.DI
import org.kodein.di.DIAware
import org.kodein.di.instance
import okhttp3.HttpUrl
import okhttp3.MediaType.Companion.toMediaType
import java.net.URLDecoder
+import kotlinx.coroutines.runBlocking
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import java.net.URI
+import okhttp3.RequestBody.Companion.toRequestBody
import com.greybox.projectmesh.util.NotificationHelper
+import com.ustadmobile.meshrabiya.log.MNetLogger
+import timber.log.Timber
/*
This File is the Server for transferring files
@@ -52,13 +71,15 @@ The Meshrabiya test app uses NanoHttpD as the server, OkHttp as the client
class AppServer(
private val appContext: Context,
private val httpClient: OkHttpClient, // OkHttp client for making HTTP requests
+ private val mLogger: MNetLogger,
name: String,
port: Int = 0, // Port for NanoHTTPD server, default is 0
- private val localVirtualAddr: InetAddress,
+ val localVirtualAddr: InetAddress,
private val receiveDir: File, // Directory for receiving files
private val json: Json,
private val db: MeshDatabase,
override val di: DI,
+ private val userRepository: UserRepository
) : NanoHTTPD(port), Closeable, DIAware {
private val logPrefix: String = "[AppServer - $name] "
@@ -69,14 +90,36 @@ class AppServer(
PENDING, IN_PROGRESS, COMPLETED, FAILED, DECLINED
}
+
+ private fun handleMyInfoRequest(): Response {
+ val sharedPrefs: SharedPreferences by di.instance(tag = "settings")
+ val localUuid = sharedPrefs.getString("UUID", null) ?: return newFixedLengthResponse(
+ Response.Status.INTERNAL_ERROR, "application/json", """{"error":"No local UUID found"}"""
+ )
+
+ val localUser = runBlocking { userRepository.getUser(localUuid) } ?: return newFixedLengthResponse(
+ Response.Status.INTERNAL_ERROR, "application/json", """{"error":"No local user record in DB"}"""
+ )
+
+ // Add the local IP to the address field so it comes through in JSON
+ val localUserWithAddr = localUser.copy(
+ address = localVirtualAddr.hostAddress // or any IP you want to send
+ )
+
+ val userJson = json.encodeToString(UserEntity.serializer(), localUserWithAddr)
+ return newFixedLengthResponse(Response.Status.OK, "application/json", userJson)
+ }
+
+
// Restart method to stop and start the server with an optional new IP address
fun restart() {
stop() // Stop the server using NanoHTTPD's built-in stop method
- Log.d("AppServer", "Server stopped successfully")
+ Timber.d("AppServer", "Server stopped successfully")
start(SOCKET_READ_TIMEOUT, false) // Start the server using NanoHTTPD's built-in start method
- Log.d("AppServer", "Server restarted successfully on port: $localPort")
+ Timber.d("AppServer", "Server restarted successfully on port: $localPort")
}
+//change to json
/*
This data class contains all the information about the outgoing transfer (Sending a file)
Why not using Serializable annotation?
@@ -148,7 +191,7 @@ class AppServer(
init {
scope.launch {
// fetch all files in receiveDir directory that end with .rx.json extension
- val incomingFiles = receiveDir.listFiles { file, fileName: String? ->
+ val incomingFiles = receiveDir.listFiles { _ , fileName: String? ->
fileName?.endsWith(".rx.json") == true
}?.map {
// It deserializes the JSON file into an IncomingTransferInfo object
@@ -177,8 +220,70 @@ class AppServer(
override fun serve(session: IHTTPSession): Response {
// Extracts the URI from the session, which is the path of the request
val path = session.uri
+ mLogger(Log.INFO, "$logPrefix : ${session.method} ${session.uri}")
+ //Create instance of the JSON Schema
+ val JSONschema = JSONSchema()
+
+ if (path.startsWith("/ping")) {
+ //Simple endpoint to check if server is responsive
+ return newFixedLengthResponse("PONG")
+ }
+
// check if the path is for download, indicating the request wants to download a file
- if(path.startsWith("/download/")) {
+ // 1) /myinfo route
+ if (path.startsWith("/myinfo")) {
+ return handleMyInfoRequest()
+ }
+ else if (path.startsWith("/updateUserInfo")) {
+ // Read the POST body (assumed JSON)
+ val postData = session.inputStream.bufferedReader().readText()
+
+ //Validates JSON payload
+ if(!JSONschema.schemaValidation(postData)){
+ return newFixedLengthResponse(
+ Response.Status.BAD_REQUEST, "application/json", """{"error":"Invalid JSON schema"}"""
+ )
+ }
+
+ try {
+ // Decode the JSON payload into a UserEntity
+ val updatedUser = json.decodeFromString(UserEntity.serializer(), postData)
+ // Update or insert the user info in the database
+ runBlocking {
+ userRepository.insertOrUpdateUser(updatedUser.uuid, updatedUser.name, updatedUser.address)
+ }
+ return newFixedLengthResponse(
+ Response.Status.OK, "application/json", """{"status":"OK"}"""
+ )
+ } catch (e: Exception) {
+ e.printStackTrace()
+ return newFixedLengthResponse(
+ Response.Status.BAD_REQUEST, "application/json", """{"error":"Invalid user data"}"""
+ )
+ }
+ }
+ else if (path.startsWith("/updateUserInfo")) {
+ // Read the POST body (assumed JSON)
+ val postData = session.inputStream.bufferedReader().readText()
+ try {
+ // Decode the JSON payload into a UserEntity
+ val updatedUser = json.decodeFromString(UserEntity.serializer(), postData)
+ // Update or insert the user info in the database
+ runBlocking {
+ userRepository.insertOrUpdateUser(updatedUser.uuid, updatedUser.name, updatedUser.address)
+ }
+ return newFixedLengthResponse(
+ Response.Status.OK, "application/json", """{"status":"OK"}"""
+ )
+ } catch (e: Exception) {
+ e.printStackTrace()
+ return newFixedLengthResponse(
+ Response.Status.BAD_REQUEST, "application/json", """{"error":"Invalid user data"}"""
+ )
+ }
+ }
+ // 2) /download/
+ else if (path.startsWith("/download/")) {
// Extracts the transfer ID (Integer)from the path by taking the last part of the path
val xferId = path.substringAfterLast("/").toInt()
// Find the outgoing transfer with the given xferId
@@ -193,10 +298,12 @@ class AppServer(
// If the input stream could not be opened, the function returns an HTTP response
// with a status of INTERNAL_ERROR and an error message
if(contentIn == null) {
+ mLogger(Log.ERROR, "$logPrefix Failed to open input stream to serve $path - ${outgoingXfer.uri}")
return newFixedLengthResponse(
Response.Status.INTERNAL_ERROR, "text/plain",
"Failed to open InputStream")
}
+ mLogger(Log.INFO, "$logPrefix Sending file for xfer #$xferId")
// Preparing the file for download
val response = newFixedLengthResponse(
Response.Status.OK, "application/octet-stream",
@@ -236,7 +343,7 @@ class AppServer(
}else {
Status.FAILED
}
-
+ mLogger(Log.INFO, "$logPrefix Sending file for xfer #$xferId")
/*
Updating _outgoingTransfers again to set the final transferred bytes and status
(COMPLETED or FAILED).
@@ -258,6 +365,7 @@ class AppServer(
}
// Check if it is a sending request
else if(path.startsWith("/send")) {
+ mLogger(Log.INFO, "$logPrefix Received incoming transfer request")
// Parse the query parameters from the URL, converting them to a key-value map
val searchParams = session.queryParameterString.split("&")
.map {
@@ -270,34 +378,68 @@ class AppServer(
// if size is missing or invalid, then defaults to -1
val size = searchParams["size"]?.toInt() ?: -1
val fromAddr = searchParams["from"]
- val devicename = fromAddr?.let { GlobalApp.DeviceInfoManager.getDeviceName(it) }
+
// if everything is ready, create a new incomingTransferInfo object that contains all the
// info extract from the query parameters
if(id != null && filename != null && fromAddr != null) {
+ val ipStr = fromAddr
+ val userName = runBlocking {
+ val user = userRepository.getUserByIp(ipStr)
+ user?.name ?: "Unknown Device"
+ }
+
val incomingTransfer = IncomingTransferInfo(
id = id.toInt(),
fromHost = InetAddress.getByName(fromAddr),
name = filename,
size = size,
- deviceName = devicename ?: ""
+ deviceName = userName
)
- /*
- update the _incomingTransfers list with the new incoming transfer
- The new list is added to the top of the list, then existing list are
- appended after the new one.
- */
+
+ //find if theres an existing convo from sender
+ val user = runBlocking { userRepository.getUserByIp(ipStr) }
+
+ var routeToChatEnabled = false
+ var chatConversationId: String? = null
+
+ if (user != null ) {
+ val localUuid = GlobalApp.GlobalUserRepo.prefs.getString("UUID", null) ?: "local-user"
+ try {
+ val conversation = runBlocking {
+ GlobalApp.GlobalUserRepo.conversationRepository.getOrCreateConversation(
+ localUuid = localUuid,
+ remoteUser = user
+ )
+ }
+ routeToChatEnabled = true
+ chatConversationId = conversation.id
+ } catch (e: Exception) {
+ Timber.tag("AppServer").e(e, "Failed to find conversation for file " +
+ "sender")
+ }
+ }
+
+ //update the _incomingTransfers list with new incoming transers
+ //then the new list is added to the top
_incomingTransfers.update { prev ->
buildList {
add(incomingTransfer)
addAll(prev)
}
}
- // Show notification
- NotificationHelper.showFileReceivedNotification(appContext, filename)
- // Return "OK", Confirming the transfer request has been handled
+
+ //show notification based on whether we have a conversation from the sender
+ if (routeToChatEnabled && chatConversationId != null) {
+ showFileInChatNotification(incomingTransfer, chatConversationId)
+ } else {
+ // Fall back to the regular file notification
+ NotificationHelper.showFileReceivedNotification(appContext, filename)
+ mLogger(Log.INFO, "$logPrefix Added request id $id for $filename from ${incomingTransfer.fromHost}")
+ }
return newFixedLengthResponse("OK")
}else {
+ mLogger(Log.INFO, "$logPrefix incomin transfer request - bad request - missing params")
// Return an error response if any of the required parameters are missing
return newFixedLengthResponse(Response.Status.BAD_REQUEST, "text/plain", "Bad request")
}
@@ -322,23 +464,101 @@ class AppServer(
return newFixedLengthResponse("OK")
}
else if(path.startsWith("/getDeviceName")){
- Log.d("AppServer", "local ip address: ${localVirtualAddr.hostAddress}")
+ Timber.tag("AppServer").d("local ip address: ${localVirtualAddr.hostAddress}")
val settingPref: SharedPreferences by di.instance(tag="settings")
return newFixedLengthResponse(settingPref.getString("device_name", Build.MODEL) ?: Build.MODEL)
}
else if(path.startsWith("/chat")) {
- val chatMessage = session.parameters["chatMessage"]?.first() ?: "Error! No message found."
- val time = session.parameters["time"]?.first()?.toLong() ?: 0
- val senderIp = InetAddress.getByName(session.parameters["senderIp"]?.first() ?: "0.0.0.0")
- val sender: String = GlobalApp.DeviceInfoManager.getDeviceName(senderIp) ?: "Unknown"
- val chatName: String = GlobalApp.DeviceInfoManager.getChatName(senderIp)
- Log.d("Appserver", "chatMessage: $chatMessage, time: $time, sender: $sender, chatName: $chatName")
- scope.launch {
- db.messageDao().addMessage(Message(0, time, chatMessage, sender, chatName))
+ //Timber.d("AppServer", "Received chat message*******")
+ //Processes JSON payload into useable data
+ val files = mutableMapOf()
+ session.parseBody(files)
+ val jsonPayload = files["postData"] // This is where the full body lives
+ //Timber.d("AppServer", "JSON Payload******: $jsonPayload")
+
+ //Checks if payload is null/blank
+ if (jsonPayload.isNullOrBlank()) {
+ Timber.tag("AppServer").e("Empty or missing JSON payload")
+ return newFixedLengthResponse(Response.Status.BAD_REQUEST, "text/plain", "Empty or missing JSON payload")
+ }else{
+ Timber.tag("AppServer").d("JSON payload not blank")
}
- return newFixedLengthResponse("OK")
+
+ //Validates validity of JSON payload
+ val JSONschema = JSONSchema()
+ Timber.d("AppServer", "Validating JSON payload: ${jsonPayload::class.simpleName}")
+ if (!JSONschema.schemaValidation(jsonPayload)) {
+ Timber.e("AppServer", "Invalid JSON payload")
+ return newFixedLengthResponse(Response.Status.BAD_REQUEST, "application/json", """{"error":"Invalid JSON schema"}""")
+ }else{
+ Timber.d("AppServer", "Valid JSON payload")
+ }
+
+ //Deserialize the JSON payload
+ val deserialzedJSON = json.decodeFromString(jsonPayload)
+
+ val chatMessage = deserialzedJSON.content ?: null
+ val time = deserialzedJSON.dateReceived ?: System.currentTimeMillis()
+ val senderIpStr = deserialzedJSON.sender ?: null
+
+ Timber.tag("AppServer").d("Received chat message: '$chatMessage' from $senderIpStr at" +
+ " " +
+ "$time")
+// val chatMessage = session.parameters["chatMessage"]?.firstOrNull()
+// val timeParam = session.parameters["time"]?.firstOrNull()
+// val time = timeParam?.toLongOrNull() ?: System.currentTimeMillis()
+// val senderIpStr = session.parameters["senderIp"]?.firstOrNull()
+
+ if (senderIpStr == null) {
+ return newFixedLengthResponse(Response.Status.BAD_REQUEST, "text/plain", "Missing senderIp parameter")
+ }
+
+ val senderIp = try {
+ InetAddress.getByName(senderIpStr)
+ } catch (e: Exception) {
+ Timber.tag("AppServer").e(e,"Invalid sender IP address: $senderIpStr")
+ return newFixedLengthResponse(Response.Status.BAD_REQUEST, "text/plain", "Invalid sender IP")
+ }
+
+ // Handle optional file parameter
+ //val fileUriStr = session.parameters["incomingfile"]?.firstOrNull()
+ val fileUriStr = deserialzedJSON.file?.toString()
+ val incomingfile = if (fileUriStr != null) {
+ try {
+ URI.create(fileUriStr)
+ } catch (e: Exception) {
+ Timber.tag("AppServer").e(e,"Invalid file URI: $fileUriStr")
+ null
+ }
+ } else {
+ null
+ }
+
+ Timber.tag("AppServer").d("Received chat message: '$chatMessage' from $senderIpStr")
+
+ try {
+ val message = MessageNetworkHandler.handleIncomingMessage(
+ chatMessage,
+ time,
+ senderIp,
+ incomingfile
+ )
+
+ scope.launch {
+ db.messageDao().addMessage(message)
+ Timber.tag("AppServer").d("Message saved to database: $message")
+ }
+
+ // Change response type to ensure it's properly formatted
+ return newFixedLengthResponse(Response.Status.OK, "text/plain", "OK")
+ } catch (e: Exception) {
+ Timber.e("AppServer", "Error processing chat message", e)
+ return newFixedLengthResponse(Response.Status.INTERNAL_ERROR, "text/plain", "Error processing message")
+ }
+
}
else {
+ mLogger(Log.INFO, "$logPrefix : $path - NOT FOUND")
// Returns a NOT_FOUND response indicating that the requested path could not be found.
return newFixedLengthResponse(
Response.Status.NOT_FOUND, "text/plain", "not found: $path"
@@ -349,41 +569,119 @@ class AppServer(
suspend fun sendDeviceName(wifiAddress: InetAddress, port: Int = DEFAULT_PORT){
scope.launch {
try {
- Log.d("AppServer", "wifiAddress: $wifiAddress")
- // Send local device's name to the remote device
- val uri = "http://${wifiAddress.hostAddress}:$port/getDeviceName"
- Log.d("AppServer", "URI: $uri")
+ val ipStr = wifiAddress.hostAddress
+ Timber.tag("AppServer").d("wifiAddress: $ipStr")
+
+ // GET /getDeviceName
+ val uri = "http://$ipStr:$port/getDeviceName"
val request = Request.Builder().url(uri).build()
- Log.d("AppServer", "Request: $request")
+ Timber.tag("AppServer").d("Request: $request")
val response = httpClient.newCall(request).execute()
- Log.d("AppServer", "Response: $response")
- // Get the remote device's name
+ Timber.tag("AppServer").d("Response: $response")
+
+ // The remote device's name
val remoteDeviceName = response.body?.string()
- Log.d("AppServer", "Remote device name: $remoteDeviceName")
+ Timber.tag("AppServer").d("Remote device name: $remoteDeviceName")
- if (remoteDeviceName != null) {
- wifiAddress.hostAddress?.let {
- GlobalApp.DeviceInfoManager.addDevice(
- it,
- remoteDeviceName
- )
+ response.close() // best practice: close the response
+
+ if (!remoteDeviceName.isNullOrEmpty()) {
+ runBlocking {
+ val existingUser = userRepository.getUserByIp(ipStr)
+ if (existingUser == null) {
+ // No user? Insert with a temporary or random UUID
+ val pseudoUuid = "temp-$ipStr"
+ userRepository.insertOrUpdateUser(
+ uuid = pseudoUuid,
+ name = remoteDeviceName,
+ address = ipStr
+ )
+ } else {
+ // Already have a user? Update the name
+ userRepository.insertOrUpdateUser(
+ uuid = existingUser.uuid,
+ name = remoteDeviceName,
+ address = existingUser.address
+ )
+ }
}
}
+
} catch (e: Exception) {
e.printStackTrace()
- Log.e(
- "AppServer", "Failed to get device name from " +
- wifiAddress.hostAddress
- )
+ Timber.tag("AppServer").e("Failed to get device name from ${wifiAddress
+ .hostAddress}")
}
}
}
+ /*fun requestRemoteUserInfo(remoteAddr: InetAddress, port: Int = DEFAULT_PORT) {//old
+ scope.launch {
+ try {
+ val url = "http://${remoteAddr.hostAddress}:$port/myinfo"
+ val request = Request.Builder().url(url).build()
+ val response = httpClient.newCall(request).execute()
+ val userJson = response.body?.string()
+ response.close()
+
+ if (!userJson.isNullOrEmpty()) {
+ // Decode JSON into a UserEntity
+ val remoteUser = json.decodeFromString(UserEntity.serializer(), userJson)
+ // Insert or update in DB
+ userRepository.insertOrUpdateUser(remoteUser.uuid, remoteUser.name)
+ // Possibly store lastSeen, remote IP, etc., if your entity includes those fields
+ }
+ } catch (e: Exception) {
+ Timber.e("AppServer", "Failed to fetch /myinfo from $remoteAddr", e)
+ }
+ }
+ }*/
/**
* Add an outgoing transfer. This is done using a Uri so that we don't have to make our own
* copy of the file the user wants to transfer.
*/
- fun addOutgoingTransfer(
+
+ // Add a new function to show notifications that route to the chat screen
+ private fun showFileInChatNotification(transfer: IncomingTransferInfo, conversationId: String) {
+ try {
+ val title = "File Received"
+ val content = "Tap to view ${transfer.name} in chat"
+
+ val intent = Intent(appContext, MainActivity::class.java).apply {
+ action = "OPEN_CHAT_CONVERSATION"
+ putExtra("conversationId", conversationId)
+ putExtra("from_notification", true)
+ flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+ }
+
+ val pendingIntent = PendingIntent.getActivity(
+ appContext, 1005, intent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+ )
+
+ val channelId = "file_receive_channel"
+
+ val notification = NotificationCompat.Builder(appContext, channelId)
+ .setSmallIcon(R.drawable.ic_launcher_foreground)
+ .setContentTitle(title)
+ .setContentText(content)
+ .setPriority(NotificationCompat.PRIORITY_HIGH)
+ .setDefaults(NotificationCompat.DEFAULT_VIBRATE or NotificationCompat.DEFAULT_SOUND)
+ .setContentIntent(pendingIntent)
+ .setAutoCancel(true)
+ .build()
+
+ val notificationManager = appContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+ notificationManager.notify(1005, notification)
+
+ Timber.d("AppServer", "Showed notification for file in chat")
+ } catch (e: Exception) {
+ Timber.e("AppServer", "Failed to show file in chat notification", e)
+ // Fall back to regular notification
+ NotificationHelper.showFileReceivedNotification(appContext, transfer.name)
+ }
+ }
+
+ fun addOutgoingTransfer(//change to json
uri: Uri, // The uri of the file to be transferred
toNode: InetAddress, // The recipient's IP address
toPort: Int = DEFAULT_PORT, // The recipient's port number
@@ -394,7 +692,7 @@ class AppServer(
// customized extension function of ContentResolver
val nameAndSize = appContext.contentResolver.getUriNameAndSize(uri)
val validName = nameAndSize.name ?: "unknown"
- Log.d("AppServer", "$logPrefix adding outgoing transfer of $uri " +
+ mLogger(Log.INFO, "$logPrefix adding outgoing transfer of $uri " +
"(name=${nameAndSize.name} size=${nameAndSize.size} to $toNode:$toPort")
// create an OutgoingTransferInfo object with all transfer information
@@ -405,23 +703,32 @@ class AppServer(
toHost = toNode,
size = nameAndSize.size.toInt(),
)
- // Build the request to tell the other side about the transfer
- val request = Request.Builder().url("http://${toNode.hostAddress}:$toPort/" +
- "send?id=$transferId&filename=${URLEncoder.encode(validName, "UTF-8")}" +
- "&size=${nameAndSize.size}&from=${localVirtualAddr.hostAddress}")
-// .addHeader("connection", "close")
- .build()
- Log.d("Appserver", "$logPrefix notifying $toNode of incoming transfer")
- Log.d("AppServer", "request: $request")
-
- // Send the request to the other side using OkHttp3
- val response = httpClient.newCall(request).execute()
- val serverResponse = response.body?.string()
- Log.d("AppServer", "$logPrefix - received response: $serverResponse")
- /*
- Update the _outgoingTransfers list with the new transfer
- Add the new transfer to the beginning of the list, then append the existing list
- */
+
+ scope.launch(Dispatchers.IO){
+ try{
+
+ val gs = Gson()
+ val json = gs.toJson(outgoingTransfer)
+
+ val bodtype = "application/json; charset=utf-8".toMediaTypeOrNull()
+ val bod = json.toRequestBody(bodtype)
+ val request = Request.Builder().url("http://${toNode.hostAddress}:$toPort/" +
+ "send?id=$transferId&filename=${URLEncoder.encode(validName, "UTF-8")}" +
+ "&size=${nameAndSize.size}&from=${localVirtualAddr.hostAddress}")
+ .post(bod)
+ .build()//changed this to send a post request
+
+ mLogger(Log.INFO, "$logPrefix notifying $toNode of incoming transfer")
+
+ val resp = httpClient.newCall(request).execute()
+ val serverResponse = resp.body?.string()
+ mLogger(Log.INFO, "$logPrefix - received response: $serverResponse")
+
+ } catch(e: Exception){
+ mLogger(Log.ERROR, "$logPrefix - exception: $e")
+ }
+ }
+
_outgoingTransfers.update { prev ->
buildList {
add(outgoingTransfer)
@@ -431,6 +738,12 @@ class AppServer(
return outgoingTransfer
}
+ fun removeOutgoingTransfer(transferId: Int) {
+ _outgoingTransfers.update { prev ->
+ prev.filter { it.id != transferId }
+ }
+ }
+
/*
Accept an incoming transfer
*/
@@ -521,8 +834,11 @@ class AppServer(
jsonFile.writeText(json.encodeToString(IncomingTransferInfo.serializer(), incomingTransfer))
}
val speedKBS = transfer.size / transferDurationMs
+ mLogger(Log.INFO, "$logPrefix acceptIncomingTransfer successful: Downloaded " +
+ "${transfer.size}bytes in ${transfer.transferTime}ms ($speedKBS) KB/s")
}
catch(e: Exception) {
+ mLogger(Log.ERROR, "$logPrefix acceptIncomingTransfer ($transfer) FAILED", e)
_incomingTransfers.update { prev ->
prev.updateItem(
condition = { it.id == transfer.id },
@@ -536,6 +852,25 @@ class AppServer(
}
}
+ /**
+ * Checks if a device is reachable at the application level
+ * This performs a lightweight check without doing a full user info exchange
+ */
+ fun checkDeviceReachable(remoteAddr: InetAddress, port: Int = DEFAULT_PORT): Boolean {
+ try {
+ val url = "http://${remoteAddr.hostAddress}:$port/ping"
+ val request = Request.Builder().url(url).build()
+
+ httpClient.newCall(request).execute().use { response ->
+ return response.isSuccessful
+ }
+ } catch (e: Exception) {
+ Timber.tag("AppServer").e(e, "Failed to check if device ${remoteAddr.hostAddress} is " +
+ "reachable")
+ return false
+ }
+ }
+
/*
Decline an incoming transfer
It sends an HTTP request to notify the sender that the file transfer has been
@@ -559,7 +894,10 @@ class AppServer(
// Send the request to the sender and get the response
val response = httpClient.newCall(request).execute()
val strResponse = response.body?.string()
- }catch(_: Exception) { }
+ mLogger(Log.DEBUG, "$logPrefix - onDeclineIncomingTransfer - request to: ${request.url} : response = $strResponse")
+ }catch(e: Exception) {
+ mLogger(Log.WARN, "$logPrefix - onDeclineIncomingTransfer : exception- request to: ${request.url} : FAIL", e)
+ }
}
// update the _incomingTransfers list, setting the status to DECLINED
_incomingTransfers.update { prev ->
@@ -601,13 +939,126 @@ class AppServer(
_incomingTransfers.update { prev ->
prev.filter { it.id != incomingTransfer.id }
}
+
+ // Ensure Jetpack Compose recomposes UI before handling another delete
+ withContext(Dispatchers.Main) {
+ delay(150)
+ }
}
}
- fun sendChatMessage(address: InetAddress, time: Long, message: String) {
- scope.launch {
+ /**
+ * Send a chat message and return delivery status
+ */
+ suspend fun sendChatMessageWithStatus(address: InetAddress, time: Long, message: String, f: URI?): Boolean {
+
+ try {
+ if (TestDeviceService.isTestDevice(address)) {
+ // Create an echo response from our test device
+ val testMessage = Message(
+ id = 0,
+ dateReceived = System.currentTimeMillis(),
+ content = "Echo: $message",
+ sender = TestDeviceService.TEST_DEVICE_NAME,
+ chat = TestDeviceService.TEST_DEVICE_NAME,
+ file = f //dont send file with echo messages
+ )
+
+ // Store the echo response in our database
+ db.messageDao().addMessage(testMessage)
+ Timber.tag("AppServer").d("Test device echoed message: $message")
+ return true
+ }
+
+ // Original code for real devices
+ val httpUrl = HttpUrl.Builder()
+ .scheme("http")
+ .host(address.hostAddress)
+ .port(DEFAULT_PORT)
+ .addPathSegment("chat")
+ .addQueryParameter("chatMessage", message)
+ .addQueryParameter("time", time.toString())
+ .addQueryParameter("senderIp", localVirtualAddr.hostAddress)
+ .build()
+
+ Timber.tag("AppServer").d("Request URL: $httpUrl")
+
+ val gs = Gson()
+ val msg = Message(//test this
+ id = 0,
+ dateReceived = time,
+ sender = localVirtualAddr.hostName,
+ chat = address.hostAddress,
+ content = message,
+ file = null//made the file null so that the file doesn't send
+ )
+ Timber.d("AppServer", "Messagefile: ${msg.file.toString()}")
+ val msgJson = gs.toJson(msg)
+ //modified http
+ val httpURL = HttpUrl.Builder() .scheme("http") .host(address.hostAddress) .port(DEFAULT_PORT) .addPathSegment("chat").build()
+ //Timber.d("AppServer", "HTTP URL: $httpURL")
+ //post request body
+ val mt = "application/json; charset=utf-8".toMediaType()
+ val rbody = msgJson.toRequestBody(mt)
+ //Timber.d("Appserver", "HTTP URL: $httpUrl")
+
+ val request = Request.Builder()
+ .url(httpUrl)
+ .post(rbody)
+ .addHeader("Content-Type", "application/json")
+ .build()
+
+ // Execute the request with proper error handling
try {
- Log.d("AppServer", "chat message: $message")
+ httpClient.newCall(request).execute().use { response ->
+ val successful = response.isSuccessful
+ if (successful) {
+ Timber.tag("AppServer").d("Message successfully sent to ${address
+ .hostAddress}")
+ } else {
+ Timber.tag("AppServer").d("Failed to send message to ${address
+ .hostAddress}, status code: ${response.code}")
+ }
+ return successful
+ }
+ } catch (e: Exception) {
+ Timber.tag("AppServer").e(e,"Failed to send message to ${address.hostAddress}: ${e
+ .message}")
+ return false
+ }
+
+ } catch (e: Exception) {
+ e.printStackTrace()
+ Timber.tag("AppServer").d("Failed to send message to ${address.hostAddress}: ${e.message}")
+ return false
+ }
+ }
+
+ /*
+
+ fun sendChatMessage(address: InetAddress, time: Long, message: String, f: URI?) {//need to test this
+ scope.launch {//check to see if this accommodates for json
+ //not sending URI, i don't think the json is working
+ try {
+ Timber.tag("AppServer").d("chat message: $message")
+ if (TestDeviceService.isTestDevice(address)) {
+ // Create an echo response from our test device
+ val testMessage = Message(
+ id = 0,
+ dateReceived = System.currentTimeMillis(),
+ content = "Echo: $message",
+ sender = TestDeviceService.TEST_DEVICE_NAME,
+ chat = TestDeviceService.TEST_DEVICE_NAME,
+ file = f//ok this is working
+ )
+
+ // Store the echo response in our database
+ db.messageDao().addMessage(testMessage)
+ Timber.tag("AppServer").d("Test device echoed message: $message")
+ return@launch
+ }
+
+ //original code for real devices
val httpUrl = HttpUrl.Builder()
.scheme("http")
.host(address.hostAddress)
@@ -617,21 +1068,208 @@ class AppServer(
.addQueryParameter("time", time.toString())
.addQueryParameter("senderIp", localVirtualAddr.hostAddress)
.build()
- Log.d("Appserver", "HTTP URL: $httpUrl")
+
+ Timber.tag("AppServer").d("Request URL: $httpUrl")
+
val request = Request.Builder()
.url(httpUrl)
.build()
- Log.d("AppServer", "Request: $request")
+
val response = httpClient.newCall(request).execute()
- Log.d("AppServer", "Response: $response")
+ Timber.tag("AppServer").d("Response: ${response.code}")
+
}
catch (e: Exception) {
e.printStackTrace()
- Log.d("AppServer", "Failed to send message to ${address.hostAddress}")
+ Timber.tag("AppServer").d("Failed to send message to ${address.hostAddress}")
}
}
}
+ */
+ fun pushUserInfoTo(remoteAddr: InetAddress, port: Int = DEFAULT_PORT) {
+ scope.launch {
+ // Retrieve your local user info (assume you store your UUID in SharedPreferences)
+ val sharedPrefs: SharedPreferences by di.instance(tag = "settings")
+ val localUuid = sharedPrefs.getString("UUID", null)
+ if (localUuid == null) {
+ Timber.tag("AppServer").e("Local UUID not found, cannot push user info")
+ return@launch
+ }
+ val localUser = runBlocking { userRepository.getUser(localUuid) }
+ if (localUser == null) {
+ Timber.tag("AppServer").e("Local user info not found in DB, cannot push user info")
+ return@launch
+ }
+
+ // Convert the user info to JSON
+ val userJson = json.encodeToString(UserEntity.serializer(), localUser)
+ val url = "http://${remoteAddr.hostAddress}:$port/updateUserInfo"
+ val requestBody = userJson.toRequestBody("application/json".toMediaType())
+ val request = Request.Builder()
+ .url(url)
+ .post(requestBody)
+ .build()
+
+ Timber.tag("AppServer").d("Pushing user info to $url with payload: $userJson")
+
+ try {
+ val response = httpClient.newCall(request).execute()
+ // Timber the response code and body (if any)
+ val responseBody = response.body?.string()
+ Timber.tag("AppServer").d("Response from ${remoteAddr.hostAddress}: Code=${response
+ .code}, Body=$responseBody")
+ } catch (e: Exception) {
+ Timber.tag("AppServer").e(e,"Failed to push user info to ${remoteAddr
+ .hostAddress}")
+ }
+ }
+ }
+ fun requestRemoteUserInfo(remoteAddr: InetAddress, port: Int = DEFAULT_PORT) {
+ //Special handling for test devices
+ val ipAddress = remoteAddr.hostAddress
+
+ // Online test device should always be "online"
+ if (ipAddress == TestDeviceService.TEST_DEVICE_IP) {
+ DeviceStatusManager.updateDeviceStatus(ipAddress, true)
+ return
+ }
+
+ // Offline test device should always be "offline"
+ if (ipAddress == TestDeviceService.TEST_DEVICE_IP_OFFLINE) {
+ DeviceStatusManager.updateDeviceStatus(ipAddress, false)
+ return
+ }
+ scope.launch {
+ try {
+ val url = "http://${remoteAddr.hostAddress}:$port/myinfo"
+ val request = Request.Builder().url(url).build()
+ Timber.tag("AppServer").d("Requesting remote user info from $url")
+
+ val response = httpClient.newCall(request).execute()
+ val userJson = response.body?.string()
+ Timber.tag("AppServer").d("Received user info from ${remoteAddr.hostAddress}: " +
+ "$userJson")
+ response.close()
+
+ if (!userJson.isNullOrEmpty()) {
+ // 1) Decode JSON
+ val remoteUser = json.decodeFromString(UserEntity.serializer(), userJson)
+
+ // 2) Optionally override with the *actual* IP of the request
+ // if you prefer forcing the discovered IP over the user’s self-reported IP.
+ val remoteUserWithIp = remoteUser.copy(
+ address = remoteAddr.hostAddress
+ )
+
+ // 3) Insert or update that IP in the DB
+ userRepository.insertOrUpdateUser(
+ remoteUserWithIp.uuid,
+ remoteUserWithIp.name,
+ remoteUserWithIp.address
+ )
+
+ // 4) update user connection status to online
+ updateUserOnlineStatus(
+ userUuid = remoteUserWithIp.uuid,
+ isOnline = true,
+ userAddress = remoteUserWithIp.address
+ )
+
+ // 5) update device status manager to show device online
+ DeviceStatusManager.updateDeviceStatus(remoteAddr.hostAddress, true)
+
+ //try to create a conversation
+ try {
+ //get local UUID
+ val sharedPrefs: SharedPreferences by di.instance(tag = "settings")
+ val localUuid = sharedPrefs.getString("UUID", null)
+ if ( localUuid != null){
+ //create convo
+ GlobalApp.GlobalUserRepo.conversationRepository.getOrCreateConversation(
+ localUuid = localUuid,
+ remoteUser = remoteUserWithIp
+ )
+ Timber.tag("AppServer").d("Created conversation with ${remoteUserWithIp
+ .name}")
+ }
+ }catch (e: Exception) {
+ Timber.tag("AppServer").e(e, "Failed to create conversation")
+
+ //Update Device Status Manager to show device is offline when connection fails
+ DeviceStatusManager.updateDeviceStatus(remoteAddr.hostAddress, false)
+
+ //update convo status for this user
+ val user = runBlocking { userRepository.getUserByIp(remoteAddr.hostAddress) }
+ if (user != null) {
+ updateUserOnlineStatus(
+ userUuid = user.uuid,
+ isOnline = false,
+ userAddress = null
+ )
+ }
+ }
+
+ Timber.tag("AppServer").d("Updated local DB with remote user info: " +
+ "$remoteUserWithIp")
+ }
+ } catch (e: Exception) {
+ Timber.tag("AppServer").e(e,"Failed to fetch /myinfo from ${remoteAddr.hostAddress}")
+ }
+ }
+ }
+
+ fun updateUserConnectionStatus(userUuid: String, isOnline: Boolean, userAddress: String?) {
+ scope.launch {
+ try {
+ GlobalApp.GlobalUserRepo.conversationRepository.updateUserStatus(
+ userUuid = userUuid,
+ isOnline = isOnline,
+ userAddress = userAddress
+ )
+ Timber.tag("AppServer").d("Updated user $userUuid connection status: " +
+ "online=$isOnline, address=$userAddress")
+ }catch (e: Exception){
+ Timber.tag("AppServer").e(e,"Failed to update user connection status")
+ }
+ }
+ }
+
+ fun updateUserOnlineStatus(userUuid: String, isOnline: Boolean, userAddress: String?){
+ scope.launch {
+ try {
+ GlobalApp.GlobalUserRepo.conversationRepository.updateUserStatus(
+ userUuid = userUuid,
+ isOnline = isOnline,
+ userAddress = userAddress
+ )
+ Timber.tag("AppServer").d("Updated user $userUuid connection status: " +
+ "online=$isOnline, address=$userAddress")
+ } catch (e: Exception){
+ Timber.tag("AppServer").e(e,"Failed to update user connection status")
+ }
+ }
+ }
+
+ fun markAllUsersOffline(){
+ scope.launch {
+ try {
+ val allUsers = GlobalApp.GlobalUserRepo.userRepository.getAllConnectedUsers()
+ for (user in allUsers) {
+ GlobalApp.GlobalUserRepo.conversationRepository.updateUserStatus(
+ userUuid = user.uuid,
+ isOnline = false,
+ userAddress = null
+ )
+ }
+ Timber.tag("AppServer").d("Marked all users as offline")
+ } catch (e: Exception) {
+ Timber.tag("AppServer").e(e,"Failed to mark all users as offline")
+ }
+ }
+ }
+
+
// Stop the server and cancel any coroutine that are running within the CoroutineScope
override fun close() {
stop()
@@ -639,7 +1277,7 @@ class AppServer(
}
companion object {
- const val DEFAULT_PORT = 9614
+ const val DEFAULT_PORT = 9614//MAIN HAD MODIFIED IT TO 9614 FROM 4242
val CHAT_TYPE_PLAINTEXT = "text/plain; charset=utf-8".toMediaType()
}
}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/testing/README.md b/app/src/main/java/com/greybox/projectmesh/testing/README.md
new file mode 100644
index 00000000..d6a22a48
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/testing/README.md
@@ -0,0 +1,343 @@
+# Test Users in Project Mesh
+
+## Overview
+
+Project Mesh includes built-in test users to help with development and testing. These virtual devices simulate real connections and messaging behavior without requiring actual physical devices to be connected to the mesh network.
+
+## Available Test Users
+
+The application includes two test users:
+
+1. **Online Test Device**
+ - Name: "Test Echo Device (Online)"
+ - IP Address: 192.168.0.99
+ - Status: Always appears as online
+ - Behavior: Automatically responds to messages with an echo reply
+
+2. **Offline Test Device**
+ - Name: "Test Echo Device (Offline)"
+ - IP Address: 192.168.0.98
+ - Status: Always appears as offline
+ - Status: Always appears as offline
+ - Behavior: Messages can be sent but will remain stored locally
+
+**Only Online User Shows Up as Online**:
+
+
+
+## Test User Features
+
+- **Automatic Initialization**: Test users are automatically initialized when the app starts.
+- **Persistent Conversations**: Conversations with test users persist across app restarts.
+- **Echo Functionality**: The online test device automatically responds to messages with an "Echo: [your message]" reply.
+- **Status Management**: Test devices maintain consistent online/offline status regardless of network conditions.
+
+## Usage Examples
+
+### Testing Message Delivery
+1. Navigate to the Chat screen
+2. Select "Test Echo Device (Online)" from the conversation list
+3. Send a message
+4. You should receive an echo reply within seconds
+
+
+
+### Testing Offline Message Behavior
+1. Navigate to the Chat screen
+2. Select "Test Echo Device (Offline)" from the conversation list
+3. Send a message
+4. The message will show as sent but will be stored locally with an offline indicator
+
+
+
+## Technical Implementation
+
+The test devices are implemented through several components:
+
+- `TestDeviceService`: Main service that manages test device creation and behavior
+- `TestDeviceEntry`: Creates virtual network entries for test devices
+- `TestVirtualRouter`: Simulates network routing for test devices
+- `DeviceStatusManager`: Handles special status tracking for test devices
+
+## Customization
+
+To modify test device behavior, you can edit the following properties in `TestDeviceService.kt`:
+
+```kotlin
+// Define test device properties
+const val TEST_DEVICE_IP = "192.168.0.99"
+const val TEST_DEVICE_NAME = "Test Echo Device (Online)"
+const val TEST_DEVICE_IP_OFFLINE = "192.168.0.98"
+const val TEST_DEVICE_NAME_OFFLINE = "Test Echo Device (Offline)"
+```
+
+## Test User Integration
+
+### How Test Users Connect with the Project Mesh Architecture
+Test users are integrated into several key components of the Project Mesh architecture to simulate real devices without requiring actual physical connections. Here's how they interface with the core systems:
+1. TestDeviceService Integration
+```kotlin
+// In TestDeviceService.kt
+companion object {
+ const val TEST_DEVICE_IP = "192.168.0.99"
+ const val TEST_DEVICE_NAME = "Test Echo Device (Online)"
+ const val TEST_DEVICE_IP_OFFLINE = "192.168.0.98"
+ const val TEST_DEVICE_NAME_OFFLINE = "Test Echo Device (Offline)"
+
+ private var isInitialized = false
+ private var offlineDeviceInitialized = false
+
+ fun initialize() {
+ try {
+ if (!isInitialized) {
+ runBlocking {
+ val existingUser = userRepository.getUserByIp(TEST_DEVICE_IP)
+ if (existingUser == null) {
+ // If there's no user with this IP, insert one with a "temp" UUID
+ val pseudoUuid = "temp-$TEST_DEVICE_IP"
+ userRepository.insertOrUpdateUser(
+ uuid = pseudoUuid,
+ name = TEST_DEVICE_NAME,
+ address = TEST_DEVICE_IP
+ )
+ } else {
+ // If a user with this IP already exists, just update the name
+ userRepository.insertOrUpdateUser(
+ uuid = existingUser.uuid,
+ name = TEST_DEVICE_NAME,
+ address = existingUser.address
+ )
+ }
+ }
+ isInitialized = true
+ Log.d("TestDeviceService", "Test device initialized successfully with IP: $TEST_DEVICE_IP")
+
+ //initialize offline test device
+ initializeOfflineDevice()
+ }
+ } catch (e: Exception) {
+ Log.e("TestDeviceService", "Failed to initialize test device", e)
+ }
+ }
+
+ // Additional methods for test device functionality...
+}
+```
+2. Global App Integration
+```kotlin
+// In GlobalApp.kt
+override fun onCreate() {
+ super.onCreate()
+
+ // Other initialization code...
+
+ //Initialize test device:
+ TestDeviceService.initialize()
+ Log.d("MainActivity", "Test device initialized")
+
+ // Test conversation setup
+ insertTestConversations()
+}
+
+fun insertTestConversations() {
+ GlobalScope.launch {
+ try {
+ //get database instance
+ val db: MeshDatabase by di.instance()
+
+ // Check if any messages exist first
+ val existingMessages = db.messageDao().getAll()
+ Log.d("GlobalApp", "Found ${existingMessages.size} existing messages")
+
+ if (existingMessages.isEmpty()) {
+ Log.d("GlobalApp", "No messages found, creating test messages...")
+
+ val localUuid = GlobalUserRepo.prefs.getString("UUID", null) ?: "local-user"
+
+ //insert test convo with online test device
+ val testDevice = TestDeviceService.getTestDeviceAddress()
+ val testUser = UserEntity(
+ uuid = "test-device-uuid",
+ name = TestDeviceService.TEST_DEVICE_NAME,
+ address = testDevice.hostAddress
+ )
+
+ //make sure the test user exists in the database
+ GlobalUserRepo.userRepository.insertOrUpdateUser(
+ testUser.uuid,
+ testUser.name,
+ testUser.address
+ )
+
+ //create convo with the test device
+ val onlineConversation =
+ GlobalUserRepo.conversationRepository.getOrCreateConversation(
+ localUuid = localUuid,
+ remoteUser = testUser
+ )
+
+ //create online test message
+ val onlineTestMessage = Message(
+ id = 0,
+ dateReceived = System.currentTimeMillis() - 3600000, // 1 hour ago
+ content = "Hello world! This is a test message.",
+ sender = TestDeviceService.TEST_DEVICE_NAME,
+ chat = "local-user-test-device-uuid" // Use ONLY conversation ID format
+ )
+
+ //insert the message
+ db.messageDao().addMessage(onlineTestMessage)
+
+ // Also initialize offline test device with a separate conversation
+ // Similar code for offline device...
+ }
+ } catch (e: Exception) {
+ Log.e("GlobalApp", "Error inserting test conversation", e)
+ }
+ }
+}
+```
+3. AppServer Integration
+```kotlin
+// In AppServer.kt
+fun sendChatMessageWithStatus(address: InetAddress, time: Long, message: String, f: URI?): Boolean {
+ try {
+ if (TestDeviceService.isTestDevice(address)) {
+ // Create an echo response from our test device
+ val testMessage = Message(
+ id = 0,
+ dateReceived = System.currentTimeMillis(),
+ content = "Echo: $message",
+ sender = TestDeviceService.TEST_DEVICE_NAME,
+ chat = TestDeviceService.TEST_DEVICE_NAME,
+ file = f //dont send file with echo messages
+ )
+
+ // Store the echo response in our database
+ db.messageDao().addMessage(testMessage)
+ Log.d("AppServer", "Test device echoed message: $message")
+ return true
+ }
+
+ // Normal chat message handling for real devices...
+ }
+ catch (e: Exception) {
+ // Error handling...
+ }
+}
+
+fun requestRemoteUserInfo(remoteAddr: InetAddress, port: Int = DEFAULT_PORT) {
+ //Special handling for test devices
+ val ipAddress = remoteAddr.hostAddress
+
+ // Online test device should always be "online"
+ if (ipAddress == TestDeviceService.TEST_DEVICE_IP) {
+ DeviceStatusManager.updateDeviceStatus(ipAddress, true)
+ return
+ }
+
+ // Offline test device should always be "offline"
+ if (ipAddress == TestDeviceService.TEST_DEVICE_IP_OFFLINE) {
+ DeviceStatusManager.updateDeviceStatus(ipAddress, false)
+ return
+ }
+
+ // Normal remote user info handling for real devices...
+}
+```
+4. DeviceStatusManager Integration
+```kotlin
+// In DeviceStatusManager.kt
+object DeviceStatusManager {
+ // Other properties and methods...
+
+ //special test device addresses that should be handled differently
+ private val specialDevices = setOf(
+ "192.168.0.99", // Online test device
+ "192.168.0.98" // Offline test device
+ )
+
+ fun updateDeviceStatus(ipAddress: String, isOnline: Boolean, verified: Boolean = false) {
+ //if this is a special device, handle according to its predefined status
+ if (ipAddress == "192.168.0.99") { // Online test device
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = true
+ mutable
+ }
+ Log.d("DeviceStatusManager", "Updated test device status for $ipAddress: online")
+ return
+ } else if (ipAddress == "192.168.0.98") { // Offline test device
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = false
+ mutable
+ }
+ Log.d("DeviceStatusManager", "Updated test device status for $ipAddress: offline")
+ return
+ }
+
+ // Normal device status handling for real devices...
+ }
+
+ fun verifyDeviceStatus(ipAddress: String) {
+ // Skip verification for special test devices
+ if (ipAddress in specialDevices) {
+ return
+ }
+
+ // Normal device verification for real devices...
+ }
+}
+```
+5. NetworkServiceViewModel Integration
+```kotlin
+// In NetworkScreenViewModel.kt
+init {
+ viewModelScope.launch {
+ //create test device entry
+ val testEntry = TestDeviceEntry.createTestEntry()
+
+ node.state.collect { nodeState ->
+ // Processing real node state...
+
+ // Combine real nodes with test device
+ val allNodesWithTest = nodeState.originatorMessages.toMutableMap()
+ allNodesWithTest[testEntry.first] = testEntry.second
+
+ Log.d("NetworkScreenViewModel", "Updating nodes. Count: ${allNodesWithTest.size}")
+ Log.d("NetworkScreenViewModel", "Test device address: ${testEntry.first}")
+
+ // Update UI state with combined nodes...
+ }
+ }
+}
+```
+6. ConversationsHomeScreen Integration
+ Test devices appear in the conversations list as either online or offline contacts, with special handling to ensure they have the correct status regardless of actual network conditions.
+7. ChatScreen Integration
+```kotlin
+// In ChatScreenViewModel.kt
+fun sendChatMessage(virtualAddress: InetAddress, message: String, file: URI?) {
+ // Other processing...
+
+ viewModelScope.launch {
+ //save to local database
+ db.messageDao().addMessage(messageEntity)
+
+ //update convo with the new message
+ // ...
+
+ if (isOnline) {
+ try {
+ // Send message to real device
+ // ...
+ } catch (e: Exception) {
+ // Error handling...
+ }
+ }
+ }
+}
+```
+
+The test user system integrates smoothly with the existing architecture by implementing specialized handling at key decision points throughout the codebase. This allows the test devices to behave consistently and predictably while reusing much of the same code path as real devices.
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/testing/TestDeviceEntry.kt b/app/src/main/java/com/greybox/projectmesh/testing/TestDeviceEntry.kt
new file mode 100644
index 00000000..2f6c9a07
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/testing/TestDeviceEntry.kt
@@ -0,0 +1,74 @@
+package com.greybox.projectmesh.testing
+
+import com.ustadmobile.meshrabiya.mmcp.MmcpOriginatorMessage
+import com.ustadmobile.meshrabiya.vnet.VirtualNode
+import com.ustadmobile.meshrabiya.vnet.VirtualNodeDatagramSocket
+import timber.log.Timber
+import java.net.DatagramSocket
+import java.net.InetAddress
+import java.util.concurrent.Executors
+
+class TestDeviceEntry {
+ companion object {
+ // Create a test logger
+ private val testLogger = TestMNetLogger()
+
+ fun createTestEntry(): Pair {
+ try {
+ //convert string IP to bytes
+ val testAddressBytes = TestDeviceService.TEST_DEVICE_IP
+ .split(".")
+ .map { it.toInt().toByte() }
+ .toByteArray()
+
+ val testAddress = InetAddress.getByAddress(testAddressBytes)
+
+ // Convert IP address to Int manually
+ val testAddressInt = testAddressBytes.foldIndexed(0) { index, acc, byte ->
+ acc or ((byte.toInt() and 0xFF) shl (24 - (index * 8)))
+ }
+
+ Timber.tag("TestDeviceEntry").d("Creating test entry with IP: ${TestDeviceService
+ .TEST_DEVICE_IP}")
+ Timber.tag("TestDeviceEntry").d("Test address as int: $testAddressInt")
+
+
+ //create basic MmcpOriginatorMessage
+ val mockOriginatorMessage = MmcpOriginatorMessage(
+ messageId = 1,
+ pingTimeSum = 50.toShort(),
+ connectConfig = null,
+ sentTime = System.currentTimeMillis()
+ )
+
+ //create a virtual router for testing
+ val testRouter = TestVirtualRouter()
+
+ //create a mock VirtualNodeDatagramSocket with our test router
+ val mockSocket = VirtualNodeDatagramSocket(
+ socket = DatagramSocket(),
+ ioExecutorService = Executors.newSingleThreadExecutor(),
+ router = testRouter,
+ localNodeVirtualAddress = testAddressInt,
+ logger = testLogger
+ )
+
+ // Create LastOriginatorMessage with all required parameters
+ val lastOriginatorMessage = VirtualNode.LastOriginatorMessage(
+ originatorMessage = mockOriginatorMessage,
+ timeReceived = System.currentTimeMillis(),
+ lastHopAddr = testAddressInt,
+ hopCount = 1,
+ lastHopRealInetAddr = testAddress,
+ receivedFromSocket = mockSocket,
+ lastHopRealPort = 4242
+ )
+
+ return Pair(testAddressInt, lastOriginatorMessage)
+ } catch (e: Exception) {
+ Timber.tag("TestDeviceEntry").e(e,"Error creating test entry")
+ throw e
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/testing/TestDeviceService.kt b/app/src/main/java/com/greybox/projectmesh/testing/TestDeviceService.kt
new file mode 100644
index 00000000..d5447c0d
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/testing/TestDeviceService.kt
@@ -0,0 +1,111 @@
+package com.greybox.projectmesh.testing
+
+import com.greybox.projectmesh.GlobalApp.GlobalUserRepo.userRepository
+import com.greybox.projectmesh.messaging.data.entities.Message
+import kotlinx.coroutines.runBlocking
+import timber.log.Timber
+import java.net.InetAddress
+
+class TestDeviceService {
+ companion object {
+ const val TEST_DEVICE_IP = "192.168.0.99"
+ const val TEST_DEVICE_NAME = "Test Echo Device (Online)"
+ const val TEST_DEVICE_IP_OFFLINE = "192.168.0.98"
+ const val TEST_DEVICE_NAME_OFFLINE = "Test Echo Device (Offline)"
+
+ private var isInitialized = false
+ private var offlineDeviceInitialized = false
+
+ fun initialize() {
+ try {
+ if (!isInitialized) {
+ runBlocking {
+ val existingUser = userRepository.getUserByIp(TEST_DEVICE_IP)
+ if (existingUser == null) {
+ // If there's no user with this IP, insert one with a "temp" UUID
+ val pseudoUuid = "temp-$TEST_DEVICE_IP"
+ userRepository.insertOrUpdateUser(
+ uuid = pseudoUuid,
+ name = TEST_DEVICE_NAME,
+ address = TEST_DEVICE_IP
+ )
+ } else {
+ // If a user with this IP already exists, just update the name
+ // (keeping the same uuid and address)
+ userRepository.insertOrUpdateUser(
+ uuid = existingUser.uuid,
+ name = TEST_DEVICE_NAME,
+ address = existingUser.address
+ )
+ }
+ }
+ isInitialized = true
+ Timber.tag("TestDeviceService").d("Test device initialized successfully with " +
+ "IP: $TEST_DEVICE_IP")
+
+ //initialize offline test device
+ initializeOfflineDevice()
+ }
+ } catch (e: Exception) {
+ Timber.tag("TestDeviceService").e(e,"Failed to initialize test device")
+ }
+ }
+
+ fun initializeOfflineDevice() {
+ try {
+ if (!offlineDeviceInitialized) {
+ runBlocking {
+ val existingUser = userRepository.getUserByIp(TEST_DEVICE_IP_OFFLINE)
+ if (existingUser == null) {
+ // Create a new offline test device
+ val pseudoUuid = "temp-offline-$TEST_DEVICE_IP_OFFLINE"
+ userRepository.insertOrUpdateUser(
+ uuid = pseudoUuid,
+ name = TEST_DEVICE_NAME_OFFLINE,
+ address = null // NULL address means offline
+ )
+ } else {
+ // Update existing offline device
+ userRepository.insertOrUpdateUser(
+ uuid = existingUser.uuid,
+ name = TEST_DEVICE_NAME_OFFLINE,
+ address = null // Make sure it's offline
+ )
+ }
+ }
+ offlineDeviceInitialized = true
+ Timber.tag("TestDeviceService").d("Offline test device initialized successfully")
+ }
+ } catch (e: Exception) {
+ Timber.tag("TestDeviceService").e(e, "Failed to initialize offline test device")
+ }
+ }
+
+ fun isOnlineTestDevice(address: InetAddress): Boolean {
+ return address.hostAddress == TEST_DEVICE_IP
+ }
+
+ fun isOfflineTestDevice(address: InetAddress): Boolean {
+ return address.hostAddress == TEST_DEVICE_IP_OFFLINE
+ }
+
+
+ fun getTestDeviceAddress(): InetAddress {
+ return InetAddress.getByName(TEST_DEVICE_IP)
+ }
+
+ fun isTestDevice(address: InetAddress): Boolean {
+ return address.hostAddress == TEST_DEVICE_IP
+ }
+
+ fun createEchoResponse(originalMessage: Message): Message {
+ return Message(
+ id = 0,
+ dateReceived = System.currentTimeMillis(),
+ content = "Echo: ${originalMessage.content}",
+ sender = TEST_DEVICE_NAME,
+ chat = originalMessage.chat
+ )
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/testing/TestMNetLogger.kt b/app/src/main/java/com/greybox/projectmesh/testing/TestMNetLogger.kt
new file mode 100644
index 00000000..b52a7bd0
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/testing/TestMNetLogger.kt
@@ -0,0 +1,21 @@
+package com.greybox.projectmesh.testing
+
+
+import android.util.Log
+import com.ustadmobile.meshrabiya.log.MNetLogger
+
+class TestMNetLogger : MNetLogger() {
+ override fun invoke(priority: Int, message: String, exception: Exception?) {
+ Log.println(priority, "TestDevice", message)
+ exception?.let {
+ Log.println(priority, "TestDevice", it.toString())
+ }
+ }
+
+ override fun invoke(priority: Int, message: () -> String, exception: Exception?) {
+ Log.println(priority, "TestDevice", message())
+ exception?.let {
+ Log.println(priority, "TestDevice", it.toString())
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/testing/TestVirtualRouter.kt b/app/src/main/java/com/greybox/projectmesh/testing/TestVirtualRouter.kt
new file mode 100644
index 00000000..3b843098
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/testing/TestVirtualRouter.kt
@@ -0,0 +1,38 @@
+package com.greybox.projectmesh.testing
+
+import com.ustadmobile.meshrabiya.vnet.Protocol
+import com.ustadmobile.meshrabiya.vnet.VirtualPacket
+import com.ustadmobile.meshrabiya.vnet.VirtualRouter
+import com.ustadmobile.meshrabiya.vnet.socket.ChainSocketNextHop
+import java.net.DatagramPacket
+import java.net.InetAddress
+
+class TestVirtualRouter : VirtualRouter {
+ override val address: InetAddress = InetAddress.getByName(TestDeviceService.TEST_DEVICE_IP)
+ override val localDatagramPort: Int = 4242
+ override val networkPrefixLength: Int = 16
+
+ override fun route(packet: VirtualPacket, datagramPacket: DatagramPacket?, virtualNodeDatagramSocket: com.ustadmobile.meshrabiya.vnet.VirtualNodeDatagramSocket?) {
+ // no-op for test implementation
+ }
+
+ override fun allocateUdpPortOrThrow(virtualDatagramSocketImpl: com.ustadmobile.meshrabiya.vnet.datagram.VirtualDatagramSocketImpl, portNum: Int): Int {
+ return portNum
+ }
+
+ override fun deallocatePort(protocol: Protocol, portNum: Int) {
+ // no-op for test implementation
+ }
+
+ override fun lookupNextHopForChainSocket(address: InetAddress, port: Int): ChainSocketNextHop {
+ //Return dummy next hop for testing with all required parameters
+ return ChainSocketNextHop(
+ address = address,
+ port = port,
+ isFinalDest = true,
+ network = null //For testing purposes, we can pass null for the network
+ )
+ }
+
+ override fun nextMmcpMessageId(): Int = 1
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/testing/images/OfflineTestDeviceChat.png b/app/src/main/java/com/greybox/projectmesh/testing/images/OfflineTestDeviceChat.png
new file mode 100644
index 00000000..46b00c58
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/testing/images/OfflineTestDeviceChat.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/testing/images/OnlineTestDeviceChat.png b/app/src/main/java/com/greybox/projectmesh/testing/images/OnlineTestDeviceChat.png
new file mode 100644
index 00000000..c4260eac
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/testing/images/OnlineTestDeviceChat.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/testing/images/TestDeviceNetwork.png b/app/src/main/java/com/greybox/projectmesh/testing/images/TestDeviceNetwork.png
new file mode 100644
index 00000000..aae75789
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/testing/images/TestDeviceNetwork.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/user/README.md b/app/src/main/java/com/greybox/projectmesh/user/README.md
new file mode 100644
index 00000000..4b7a58b6
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/user/README.md
@@ -0,0 +1,393 @@
+# User Profiles in Project Mesh
+
+## Overview
+Project Mesh implements a user profile system that allows devices to identify themselves on the mesh network. User profiles consist of a unique identifier (UUID), a display name, and network address information. This system enables personalized messaging and device identification across the mesh network.
+## Key Components
+### User Entity
+The core of the user profile system is the UserEntity class, which stores all user data:
+
+```kotlin
+// In UserEntity.kt
+@Serializable
+@Entity(tableName = "users")
+data class UserEntity(
+ @PrimaryKey val uuid: String,
+ val name: String,
+ val address: String? = null, // IP address, nullable
+ val lastSeen: Long? = null
+)
+```
+
+### User Repository
+The UserRepository manages all database operations related to user profiles:
+```kotlin
+// In UserRepository.kt
+class UserRepository(private val userDao: UserDao) {
+
+ suspend fun insertOrUpdateUser(uuid: String, name: String, address: String?) {
+ val existing = userDao.getUserByUuid(uuid)
+ if (existing == null) {
+ // Insert new user with address
+ userDao.insertUser(
+ UserEntity(
+ uuid = uuid,
+ name = name,
+ address = address
+ )
+ )
+ } else {
+ // Update existing user, copying over address
+ userDao.updateUser(
+ existing.copy(
+ name = name,
+ address = address
+ )
+ )
+ }
+ }
+
+ // Other repository methods...
+}
+```
+### UserData Access Object (DAO)
+The UserDao interface defines database operations:
+```kotlin
+// In UserDao.kt
+@Dao
+interface UserDao {
+ @Query("SELECT * FROM users WHERE uuid = :uuid LIMIT 1")
+ suspend fun getUserByUuid(uuid: String): UserEntity?
+
+ @Insert(onConflict = OnConflictStrategy.REPLACE)
+ suspend fun insertUser(user: UserEntity)
+
+ @Update
+ suspend fun updateUser(user: UserEntity)
+
+ @Query("SELECT EXISTS(SELECT 1 FROM users WHERE uuid = :uuid)")
+ suspend fun hasWithID(uuid: String): Boolean
+
+ @Query("SELECT * FROM users WHERE address = :ip LIMIT 1")
+ suspend fun getUserByIp(ip: String): UserEntity?
+
+ @Query("SELECT * FROM users WHERE address IS NOT NULL")
+ suspend fun getAllConnectedUsers(): List
+
+ @Query("SELECT * FROM users")
+ suspend fun getAllUsers(): List
+}
+```
+
+## User Profile Lifecycle
+### First-time Setup
+
+
+
+When a user first launches the app, they go through an onboarding process to set up their profile:
+```kotlin
+// In OnboardingViewModel.kt
+fun handleFirstTimeSetup(onComplete: () -> Unit) {
+ viewModelScope.launch {
+ // Generate or retrieve the user's UUID
+ var uuid = prefs.getString("UUID", null)
+ if (uuid.isNullOrEmpty()) {
+ uuid = UUID.randomUUID().toString()
+ prefs.edit().putString("UUID", uuid).apply()
+ }
+ // Insert or update the user with the local IP
+ userRepository.insertOrUpdateUser(
+ uuid = uuid,
+ name = _uiState.value.username,
+ address = localIp
+ )
+ prefs.edit().putString("device_name", _uiState.value.username).apply()
+ prefs.edit().putBoolean("hasRunBefore", true).apply()
+ onComplete()
+ }
+}
+```
+
+### User Information Exchange
+When devices connect, they exchange user information:
+**Before Name Exchange**:
+
+
+
+**After Name Exchange**:
+
+
+
+```kotlin
+// In AppServer.kt - requesting user info
+fun requestRemoteUserInfo(remoteAddr: InetAddress, port: Int = DEFAULT_PORT) {
+ // Special handling for test devices...
+
+ scope.launch {
+ try {
+ val url = "http://${remoteAddr.hostAddress}:$port/myinfo"
+ val request = Request.Builder().url(url).build()
+ Log.d("AppServer", "Requesting remote user info from $url")
+
+ val response = httpClient.newCall(request).execute()
+ val userJson = response.body?.string()
+
+ if (!userJson.isNullOrEmpty()) {
+ // Decode JSON
+ val remoteUser = json.decodeFromString(UserEntity.serializer(), userJson)
+
+ // Insert or update in DB
+ userRepository.insertOrUpdateUser(
+ remoteUserWithIp.uuid,
+ remoteUserWithIp.name,
+ remoteUserWithIp.address
+ )
+
+ // Update user status...
+ }
+ } catch (e: Exception) {
+ Log.e("AppServer", "Failed to fetch /myinfo from ${remoteAddr.hostAddress}", e)
+ }
+ }
+}
+
+// In AppServer.kt - providing user info
+private fun handleMyInfoRequest(): Response {
+ val sharedPrefs: SharedPreferences by di.instance(tag = "settings")
+ val localUuid = sharedPrefs.getString("UUID", null) ?: return newFixedLengthResponse(
+ Response.Status.INTERNAL_ERROR, "application/json", """{"error":"No local UUID found"}"""
+ )
+
+ val localUser = runBlocking { userRepository.getUser(localUuid) } ?: return newFixedLengthResponse(
+ Response.Status.INTERNAL_ERROR, "application/json", """{"error":"No local user record in DB"}"""
+ )
+
+ // Add the local IP to the address field
+ val localUserWithAddr = localUser.copy(
+ address = localVirtualAddr.hostAddress
+ )
+
+ val userJson = json.encodeToString(UserEntity.serializer(), localUserWithAddr)
+ return newFixedLengthResponse(Response.Status.OK, "application/json", userJson)
+}
+```
+
+### Profile Updates
+Users can update their profile information in the Settings screen:
+*Found in Settings Under Network > Device Name*:
+
+
+
+*User name can be Updated* :
+
+
+
+```kotlin
+// In SettingsScreen.kt
+onDeviceNameChange = { newDeviceName ->
+ Log.d("BottomNavApp", "Device name changed to: $newDeviceName")
+
+ // Retrieve the local UUID from SharedPreferences
+ val localUuid = settingsPrefs.getString("UUID", null)
+ if (localUuid != null) {
+ // Update the local user info and broadcast in an IO coroutine
+ CoroutineScope(Dispatchers.IO).launch {
+ // 1. Update the local user in the database
+ userRepository.insertOrUpdateUser(
+ uuid = localUuid,
+ name = newDeviceName,
+ address = appServer.localVirtualAddr.hostAddress
+ )
+
+ // 2. Broadcast updated name to connected users
+ val connectedUsers = userRepository.getAllConnectedUsers()
+ connectedUsers.forEach { user ->
+ user.address?.let { ip ->
+ try {
+ val remoteAddr = InetAddress.getByName(ip)
+ appServer.pushUserInfoTo(remoteAddr)
+ } catch (e: Exception) {
+ Log.e("BottomNavApp", "Error processing IP address: $ip", e)
+ }
+ }
+ }
+ }
+ }
+}
+```
+
+### Online Status Tracking
+The application tracks which users are online using the DeviceStatusManager:
+```kotlin
+// In DeviceStatusManager.kt
+object DeviceStatusManager {
+ private val _deviceStatusMap = MutableStateFlow>(emptyMap())
+ val deviceStatusMap: StateFlow> = _deviceStatusMap.asStateFlow()
+
+ // Updates a device's online status
+ fun updateDeviceStatus(ipAddress: String, isOnline: Boolean, verified: Boolean = false) {
+ // Special handling for test devices...
+
+ // For normal devices
+ if (verified) {
+ _deviceStatusMap.update { current ->
+ val mutable = current.toMutableMap()
+ mutable[ipAddress] = isOnline
+ mutable
+ }
+ lastCheckedTimes[ipAddress] = System.currentTimeMillis()
+ } else {
+ // Handle unverified status updates...
+ }
+ }
+
+ // Other status management methods...
+}
+```
+## Integration with UI
+User profiles are displayed in various parts of the UI:
+
+### Netowork List
+```kotlin
+// In WifiListItem.kt
+@Composable
+fun WifiListItem(
+ wifiAddress: Int,
+ wifiEntry: VirtualNode.LastOriginatorMessage,
+ onClick: ((nodeAddress: String) -> Unit)? = null,
+) {
+ // Other UI elements...
+
+ // obtain the device name according to the ip address
+ val user = runBlocking {
+ GlobalApp.GlobalUserRepo.userRepository.getUserByIp(wifiAddressDotNotation)
+ }
+ val device = user?.name ?: "Unknown"
+ if(device != null) {
+ Text(text= device, fontWeight = FontWeight.Bold)
+ }
+ else {
+ Text(text = "Loading...", fontWeight = FontWeight.Bold)
+ }
+
+ // Other UI elements...
+}
+```
+
+### ChatScreen
+
+```kotlin
+// In ChatScreen.kt
+@Composable
+fun UserStatusBar(
+ userName: String,
+ isOnline: Boolean,
+ userAddress: String
+) {
+ Card(
+ // Card styling...
+ ) {
+ Row(
+ // Row styling...
+ ) {
+ // User avatar/icon
+ Box(
+ // Avatar styling...
+ ) {
+ Text(
+ text = userName.first().toString(),
+ // Text styling...
+ )
+ }
+
+ // User name and status
+ Column {
+ Text(
+ text = userName,
+ // Text styling...
+ )
+
+ Row(
+ // Row styling...
+ ) {
+ // Status indicator dot...
+
+ // Status text
+ Text(
+ text = if (isOnline) "Online" else "Offline",
+ // Text styling...
+ )
+
+ // IP address
+ Text(
+ text = userAddress,
+ // Text styling...
+ )
+ }
+ }
+ }
+ }
+}
+```
+
+### Conversations
+
+User profiles are linked to conversations for messaging:
+
+```kotlin
+// In ConversationRepository.kt
+suspend fun getOrCreateConversation(localUuid: String, remoteUser: UserEntity): Conversation {
+ //create a unique conversation ID using both UUIDs in order to ensure consistency
+ val conversationId = ConversationUtils.createConversationId(localUuid, remoteUser.uuid)
+
+ //try to get an existing conversation
+ var conversation = conversationDao.getConversationById(conversationId)
+
+ //if no conversation exists, create a new one
+ if(conversation == null) {
+ conversation = Conversation(
+ id = conversationId,
+ userUuid = remoteUser.uuid,
+ userName = remoteUser.name,
+ userAddress = remoteUser.address,
+ lastMessage = null,
+ lastMessageTime = System.currentTimeMillis(),
+ unreadCount = 0,
+ isOnline = remoteUser.address != null
+ )
+ conversationDao.insertConversation(conversation)
+ }
+
+ return conversation
+}
+```
+
+## Technical Implementation Notes
+
+1. **UUID Generation**: UUIDs are generated using Java's UUID.randomUUID() and stored in SharedPreferences.
+2. **Persistent Storage**: User profiles are stored in a Room database, allowing them to persist across app restarts.
+3. **Network Communication**: User profiles are serialized to JSON for transmission across the network.
+4. **Online Status**: A device's online status is determined by regular connectivity checks and timeouts.
+5. **Address Management**: IP addresses are managed dynamically based on network connectivity.
+
+## Best Practices
+When working with user profiles:
+
+- **Always check for null**: IP addresses and user objects might be null, especially during initial setup.
+- **Use background threads**: Database and network operations should run on IO dispatchers, not the main thread.
+- **Handle device name changes**: When a user changes their device name, broadcast the change to all connected devices.
+- **Respect privacy**: Be mindful of what user information is stored and shared across the network.
+- **Handle connection loss**: Implement fallbacks for scenarios where user profile information cannot be retrieved.
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Missing User Profile**: If a device appears but has no name, it may indicate a failure in the user info exchange.
+2. **Incorrect Online Status**: If a device shows incorrect online status, try refreshing the network view or restarting the app.
+3. **Duplicate Users**: If multiple entries appear for the same user, there may be an issue with UUID generation or storage.
+
+## Next Steps
+
+1. **Add profile pictures**: Consider adding the ability for users to set profile pictures.
+2. **Enhance privacy options**: Allow users to control what information is shared.
+3. **Add user verification**: Implement a mechanism to verify user identities on the network.
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/user/UserDao.kt b/app/src/main/java/com/greybox/projectmesh/user/UserDao.kt
new file mode 100644
index 00000000..82f1c8de
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/user/UserDao.kt
@@ -0,0 +1,30 @@
+package com.greybox.projectmesh.user
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import androidx.room.Update
+
+@Dao
+interface UserDao {
+ @Query("SELECT * FROM users WHERE uuid = :uuid LIMIT 1")
+ suspend fun getUserByUuid(uuid: String): UserEntity?
+
+ @Insert(onConflict = OnConflictStrategy.REPLACE)
+ suspend fun insertUser(user: UserEntity)
+
+ @Update
+ suspend fun updateUser(user: UserEntity)
+
+ @Query("SELECT EXISTS(SELECT 1 FROM users WHERE uuid = :uuid)")
+ suspend fun hasWithID(uuid: String): Boolean
+
+ @Query("SELECT * FROM users WHERE address = :ip LIMIT 1")
+ suspend fun getUserByIp(ip: String): UserEntity?
+ @Query("SELECT * FROM users WHERE address IS NOT NULL")
+ suspend fun getAllConnectedUsers(): List
+
+ @Query("SELECT * FROM users")
+ suspend fun getAllUsers(): List
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/user/UserEntity.kt b/app/src/main/java/com/greybox/projectmesh/user/UserEntity.kt
new file mode 100644
index 00000000..9b4e27dd
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/user/UserEntity.kt
@@ -0,0 +1,13 @@
+package com.greybox.projectmesh.user
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import kotlinx.serialization.Serializable
+@Serializable
+@Entity(tableName = "users")
+data class UserEntity(
+ @PrimaryKey val uuid: String,
+ val name: String,
+ val address: String? = null, // Default value provided
+ val lastSeen: Long? = null
+)
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/user/UserRepository.kt b/app/src/main/java/com/greybox/projectmesh/user/UserRepository.kt
new file mode 100644
index 00000000..2b11edd5
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/user/UserRepository.kt
@@ -0,0 +1,48 @@
+package com.greybox.projectmesh.user
+
+import android.util.Log
+
+class UserRepository(private val userDao: UserDao) {
+
+ suspend fun insertOrUpdateUser(uuid: String, name: String, address: String?) {
+ val existing = userDao.getUserByUuid(uuid)
+ if (existing == null) {
+ // Insert new user with address
+ userDao.insertUser(
+ UserEntity(
+ uuid = uuid,
+ name = name,
+ address = address
+ )
+ )
+ } else {
+ // Update existing user, copying over address
+ userDao.updateUser(
+ existing.copy(
+ name = name,
+ address = address
+ )
+ )
+ }
+ }
+
+ suspend fun getUserByIp(ip: String): UserEntity? {
+ return userDao.getUserByIp(ip)
+ }
+ suspend fun getUser(uuid: String): UserEntity? {
+ return userDao.getUserByUuid(uuid)
+ }
+ suspend fun getAllConnectedUsers(): List {
+ return userDao.getAllConnectedUsers()
+ }
+
+ suspend fun getAllUsers(): List {
+ return userDao.getAllUsers()
+ }
+
+ suspend fun hasUser(uuid: String): Boolean {
+ return userDao.hasWithID(uuid)
+ }
+
+ // Add more methods as needed
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/user/images/EditingUserName.png b/app/src/main/java/com/greybox/projectmesh/user/images/EditingUserName.png
new file mode 100644
index 00000000..9590578e
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/user/images/EditingUserName.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/user/images/NetworkScreenBeforeUpdate.png b/app/src/main/java/com/greybox/projectmesh/user/images/NetworkScreenBeforeUpdate.png
new file mode 100644
index 00000000..ab5fe77f
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/user/images/NetworkScreenBeforeUpdate.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/user/images/NetworkScreenPostUpdateBob.png b/app/src/main/java/com/greybox/projectmesh/user/images/NetworkScreenPostUpdateBob.png
new file mode 100644
index 00000000..62271c12
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/user/images/NetworkScreenPostUpdateBob.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/user/images/UserNameSettings.png b/app/src/main/java/com/greybox/projectmesh/user/images/UserNameSettings.png
new file mode 100644
index 00000000..36023837
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/user/images/UserNameSettings.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/user/images/UserScreenAfterUpdateAlice.png b/app/src/main/java/com/greybox/projectmesh/user/images/UserScreenAfterUpdateAlice.png
new file mode 100644
index 00000000..d2afaf8c
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/user/images/UserScreenAfterUpdateAlice.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/user/images/User_Onboarding.png b/app/src/main/java/com/greybox/projectmesh/user/images/User_Onboarding.png
new file mode 100644
index 00000000..a4a7c2d6
Binary files /dev/null and b/app/src/main/java/com/greybox/projectmesh/user/images/User_Onboarding.png differ
diff --git a/app/src/main/java/com/greybox/projectmesh/util/NotificationHelper.kt b/app/src/main/java/com/greybox/projectmesh/util/NotificationHelper.kt
index c72d4301..ca9b8d53 100644
--- a/app/src/main/java/com/greybox/projectmesh/util/NotificationHelper.kt
+++ b/app/src/main/java/com/greybox/projectmesh/util/NotificationHelper.kt
@@ -46,7 +46,7 @@ object NotificationHelper {
.setContentTitle("File Received")
.setContentText("Tap to view $fileName")
.setPriority(NotificationCompat.PRIORITY_HIGH)
- .setDefaults(NotificationCompat.DEFAULT_VIBRATE or NotificationCompat.DEFAULT_SOUND)
+ .setDefaults(NotificationCompat.DEFAULT_ALL)
.setContentIntent(pendingIntent)
.setAutoCancel(true)
.build()
diff --git a/app/src/main/java/com/greybox/projectmesh/viewModel/ChatScreenViewModel.kt b/app/src/main/java/com/greybox/projectmesh/viewModel/ChatScreenViewModel.kt
deleted file mode 100644
index 4156ad91..00000000
--- a/app/src/main/java/com/greybox/projectmesh/viewModel/ChatScreenViewModel.kt
+++ /dev/null
@@ -1,75 +0,0 @@
-package com.greybox.projectmesh.viewModel
-
-import androidx.lifecycle.SavedStateHandle
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.greybox.projectmesh.GlobalApp
-import com.greybox.projectmesh.db.MeshDatabase
-import com.greybox.projectmesh.db.entities.Message
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import org.kodein.di.DI
-import com.greybox.projectmesh.server.AppServer
-import com.ustadmobile.meshrabiya.ext.addressToDotNotation
-import com.ustadmobile.meshrabiya.ext.requireAddressAsInt
-import com.ustadmobile.meshrabiya.vnet.AndroidVirtualNode
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import org.kodein.di.instance
-import java.net.InetAddress
-
-data class ChatScreenModel(
- val deviceName: String? = null,
- val virtualAddress: InetAddress = InetAddress.getByName("192.168.0.1"),
- val allChatMessages: List = emptyList()
-)
-
-class ChatScreenViewModel(
- di: DI,
- savedStateHandle: SavedStateHandle,
- virtualAddress: InetAddress
-): ViewModel() {
- // _uiState will be updated whenever there is a change in the UI state
- private val deviceName = GlobalApp.DeviceInfoManager.getDeviceName(virtualAddress) ?: "Unknown"
- private val addressDotNotation = virtualAddress.requireAddressAsInt().addressToDotNotation()
- private val chatName: String = GlobalApp.DeviceInfoManager.getChatName(virtualAddress)
- private val _uiState = MutableStateFlow(
- ChatScreenModel(
- deviceName = deviceName,
- virtualAddress = virtualAddress
- )
- )
- // uiState is a read-only property that shows the current UI state
- val uiState: Flow = _uiState.asStateFlow()
- // di is used to get the AndroidVirtualNode instance
- private val db: MeshDatabase by di.instance()
- private val appServer: AppServer by di.instance()
-
-
- // launch a coroutine
- init {
- viewModelScope.launch {
- // collect the state flow of the AndroidVirtualNode
- db.messageDao().getChatMessagesFlow(chatName).collect{
- newChatMessages: List ->
-
- // update the UI state with the new state
- _uiState.update { prev ->
- prev.copy(
- allChatMessages = newChatMessages
- )
- }
- }
- }
- }
-
- fun sendChatMessage(virtualAddress: InetAddress, message: String) {
- val sendTime: Long = System.currentTimeMillis()
- viewModelScope.launch {
- db.messageDao().addMessage(Message(0, sendTime, message, "Me", chatName))
- }
- appServer.sendChatMessage(virtualAddress, sendTime, message)
- }
-}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/viewModel/HomeScreenViewModel.kt b/app/src/main/java/com/greybox/projectmesh/viewModel/HomeScreenViewModel.kt
index 541a5709..2c9b4a94 100644
--- a/app/src/main/java/com/greybox/projectmesh/viewModel/HomeScreenViewModel.kt
+++ b/app/src/main/java/com/greybox/projectmesh/viewModel/HomeScreenViewModel.kt
@@ -2,7 +2,6 @@ package com.greybox.projectmesh.viewModel
import android.content.SharedPreferences
import android.os.Build
-import android.util.Log
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
@@ -22,6 +21,7 @@ import kotlinx.coroutines.launch
import kotlinx.coroutines.withTimeoutOrNull
import org.kodein.di.DI
import org.kodein.di.instance
+import timber.log.Timber
data class HomeScreenModel(
@@ -144,7 +144,7 @@ class HomeScreenViewModel(di: DI,
viewModelScope.launch {
val wasWifiConnected = _uiState.value.wifiState?.wifiStationState?.status
try {
- Log.d("HotspotDebug", "Attempt 1: Setting Hotspot to $enable")
+ Timber.tag("HotspotDebug").d("Attempt 1: Setting Hotspot to $enable")
val response = withTimeoutOrNull(1500) {
node.setWifiHotspotEnabled(
enabled = enable,
@@ -153,17 +153,17 @@ class HomeScreenViewModel(di: DI,
)
}
if (response == null) {
- Log.w("HotspotDebug", "No response within 1500ms, Retrying...")
+ Timber.tag("HotspotDebug").w("No response within 1500ms, Retrying...")
// Retry once
val retryResponse = node.setWifiHotspotEnabled(
enabled = enable,
preferredBand = _uiState.value.band,
hotspotType = _uiState.value.hotspotTypeToCreate
)
- Log.d("HotspotDebug", "Retry successful: $retryResponse")
+ Timber.tag("HotspotDebug").d("Retry successful: $retryResponse")
}
else {
- Log.d("HotspotDebug", "Hotspot set successfully: $response")
+ Timber.tag("HotspotDebug").d("Hotspot set successfully: $response")
}
if (!_concurrencyKnown.value && Build.VERSION.SDK_INT < Build.VERSION_CODES.R){
delay(500)
@@ -172,16 +172,17 @@ class HomeScreenViewModel(di: DI,
{
if(isWifiStillConnected == WifiStationState.Status.INACTIVE || isWifiStillConnected == null){
markStaApConcurrencyUnsupported()
- Log.d("HotspotDebug", "Wi-Fi disconnected after enabling hotspot. STA/AP concurrency NOT supported.")
+ Timber.tag("HotspotDebug").d("Wi-Fi disconnected after enabling hotspot. STA/AP concurrency NOT supported.")
}
else{
markStaApConcurrencySupported()
- Log.d("HotspotDebug", "Wi-Fi still connected after enabling hotspot. STA/AP concurrency supported.")
+ Timber.tag("HotspotDebug").d("Wi-Fi still connected after enabling " +
+ "hotspot. STA/AP concurrency supported.")
}
}
}
} catch (e: Exception) {
- Log.e("HotspotDebug", "Failed to set hotspot: ${e.message}")
+ Timber.tag("HotspotDebug").e("Failed to set hotspot: ${e.message}")
}
}
}
@@ -208,7 +209,7 @@ class HomeScreenViewModel(di: DI,
}
}
catch (e: Exception){
- Log.e("HomeScreenViewModel", "onConnectWifi: ${e.message}")
+ Timber.tag("HomeScreenViewModel").e("onConnectWifi: ${e.message}")
}
}
}
diff --git a/app/src/main/java/com/greybox/projectmesh/viewModel/LogScreenViewModel.kt b/app/src/main/java/com/greybox/projectmesh/viewModel/LogScreenViewModel.kt
new file mode 100644
index 00000000..56016888
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/viewModel/LogScreenViewModel.kt
@@ -0,0 +1,41 @@
+package com.greybox.projectmesh.viewModel
+
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.greybox.projectmesh.MNetLoggerAndroid
+import com.ustadmobile.meshrabiya.log.LogLine
+import com.ustadmobile.meshrabiya.log.MNetLogger
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import org.kodein.di.DI
+import org.kodein.di.direct
+import org.kodein.di.instance
+
+data class LogScreenModel(
+ val logs: List = emptyList()
+)
+
+class LogScreenViewModel(
+ di: DI,
+ savedStateHandle: SavedStateHandle
+) : ViewModel() {
+ private val _uiState = MutableStateFlow(LogScreenModel())
+ val uiState: Flow = _uiState.asStateFlow()
+ private val logger: MNetLoggerAndroid = di.direct.instance() as MNetLoggerAndroid
+
+ init {
+ viewModelScope.launch {
+ logger.recentLogs.collect {
+ _uiState.update { prev ->
+ prev.copy(
+ logs = it
+ )
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/viewModel/NetworkScreenViewModel.kt b/app/src/main/java/com/greybox/projectmesh/viewModel/NetworkScreenViewModel.kt
index 66105772..b6006867 100644
--- a/app/src/main/java/com/greybox/projectmesh/viewModel/NetworkScreenViewModel.kt
+++ b/app/src/main/java/com/greybox/projectmesh/viewModel/NetworkScreenViewModel.kt
@@ -3,20 +3,21 @@ package com.greybox.projectmesh.viewModel
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
+import com.greybox.projectmesh.DeviceStatusManager
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import org.kodein.di.DI
import com.greybox.projectmesh.server.AppServer
import com.ustadmobile.meshrabiya.ext.addressToByteArray
import com.ustadmobile.meshrabiya.vnet.AndroidVirtualNode
import com.ustadmobile.meshrabiya.vnet.VirtualNode
import com.ustadmobile.meshrabiya.vnet.wifi.state.WifiStationState
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
+import com.greybox.projectmesh.testing.TestDeviceEntry
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import org.kodein.di.DI
import org.kodein.di.instance
+import timber.log.Timber
import java.net.InetAddress
data class NetworkScreenModel(
@@ -36,30 +37,164 @@ class NetworkScreenViewModel(di:DI, savedStateHandle: SavedStateHandle): ViewMod
// launch a coroutine
init {
viewModelScope.launch {
- // collect the state flow of the AndroidVirtualNode
- node.state.collect{
+ //create test device entry
+ val testEntry = TestDeviceEntry.createTestEntry()
+ var previousNodes = emptySet()
+
+ node.state.collect { nodeState ->
+ // Get current nodes from this state update
+ val currentNodes = nodeState.originatorMessages.keys
+
+ // Check for nodes that disappeared (disconnected)
+ val disconnectedNodes = previousNodes - currentNodes
+
+ // For each disconnected node, notify DeviceStatusManager
+ disconnectedNodes.forEach { nodeAddress ->
+ val ipAddress = InetAddress.getByAddress(nodeAddress.addressToByteArray()).hostAddress
+ DeviceStatusManager.handleNetworkDisconnect(ipAddress)
+ Timber.tag("NetworkScreenViewModel").d("Detected disconnection of node: $ipAddress")
+ }
+
+ // Update previous nodes for next comparison
+ previousNodes = currentNodes
+
+ // Combine real nodes with test device
+ val allNodesWithTest = nodeState.originatorMessages.toMutableMap()
+ allNodesWithTest[testEntry.first] = testEntry.second
+
+ Timber.tag("NetworkScreenViewModel").d("Updating nodes. Count: ${allNodesWithTest
+ .size}")
+ Timber.tag("NetworkScreenViewModel").d("Test device address: ${testEntry.first}")
+ Timber.tag("NetworkScreenViewModel").d("All nodes: ${allNodesWithTest.keys}")
+
// update the UI state with the new state
- _uiState.update { prev -> prev.copy(
- // update all nodes
- allNodes = it.originatorMessages,
- // update the ssid of the connecting station
- connectingInProgressSsid =
- if (it.wifiState.wifiStationState.status == WifiStationState.Status.CONNECTING){
- it.wifiState.wifiStationState.config?.ssid
+ _uiState.update { prev ->
+ prev.copy(
+ // update all nodes
+ allNodes = allNodesWithTest,
+ // update the ssid of the connecting station
+ connectingInProgressSsid =
+ if (nodeState.wifiState.wifiStationState.status == WifiStationState.Status.CONNECTING) {
+ nodeState.wifiState.wifiStationState.config?.ssid
+ } else {
+ null
+ }
+ )
+ }
+
+ //just mark nodes as online initially - DeviceStatusManager will verify
+ allNodesWithTest.forEach { (addressInt, _) ->
+ val ipAddress =
+ InetAddress.getByAddress(addressInt.addressToByteArray()).hostAddress
+ // Update with verified=false to let the manager handle verification
+ DeviceStatusManager.updateDeviceStatus(ipAddress, true, verified = false)
+ }
+ }
+ }
+
+ /*
+ THIS LOGIC SHOULDNT BE NEEDED ANY MORE IF DEVICE STATUS MANAGER WORKS
+ viewModelScope.launch {
+ while (true) {
+ try {
+ //get all connected users
+ val connectedUsers = GlobalApp.GlobalUserRepo.userRepository.getAllConnectedUsers()
+
+ val onlineDevices = DeviceStatusManager.getOnlineDevices()
+
+ for (user in connectedUsers) {
+ user.address?.let { ipStr ->
+ try {
+ //skip test devices:
+ if (ipStr == TestDeviceService.TEST_DEVICE_IP) {
+ // Online test device should always be online
+ DeviceStatusManager.updateDeviceStatus(ipStr, true)
+ }
+ if (ipStr == TestDeviceService.TEST_DEVICE_IP_OFFLINE) {
+ // Offline test device should always be offline
+ DeviceStatusManager.updateDeviceStatus(ipStr, false)
+ }else{
+ val addr = InetAddress.getByName(ipStr)
+ val isReachable = withTimeoutOrNull(3000) {
+ addr.isReachable(2000) // 2 second timeout
+ } ?: false
+
+ if (!isReachable) {
+ // Device is not reachable at basic network level
+ throw Exception("Device is not reachable")
+ }
+
+ //ping user by requesting online info to update status
+ appServer.requestRemoteUserInfo(addr)
+
+ //Update central status manager to show device as online
+ DeviceStatusManager.updateDeviceStatus(ipStr, true)
+ Timber.tag("NetworkScreenViewModel").d("Pinged user: ${user
+ .name}
+ at $ipStr")
+ }
+ } catch (e: Exception) {
+ //if ping fails, mark user as offline
+ GlobalApp.GlobalUserRepo.conversationRepository.updateUserStatus(
+ userUuid = user.uuid,
+ isOnline = false,
+ userAddress = null
+ )
+
+ //update central status manager to show device as offline
+ DeviceStatusManager.updateDeviceStatus(ipStr, false)
+ Timber.tag("NetworkScreenViewModel").d("User ${user.name} appears
+ to be offline")
+ }
+ }
}
- else{
- null
+
+ //check any online devices that may not be in the users list
+ //i.e.: devices marked online but not properly registered as users
+ for (deviceIp in onlineDevices) {
+ if (connectedUsers.any { it.address == deviceIp } ||
+ deviceIp == TestDeviceService.TEST_DEVICE_IP ||
+ deviceIp == TestDeviceService.TEST_DEVICE_IP_OFFLINE) continue
+
+ // Skip devices we already checked in the user loop
+ if (connectedUsers.any { it.address == deviceIp }) continue
+
+ // Skip test device - it's handled differently
+ if (deviceIp == TestDeviceService.TEST_DEVICE_IP) continue
+
+ try {
+ val addr = InetAddress.getByName(deviceIp)
+ val isReachable = withTimeoutOrNull(3000) {
+ addr.isReachable(2000)
+ } ?: false
+
+ if (!isReachable) {
+ Timber.tag(
+ "NetworkScreenViewModel").d(
+ "Marking device $deviceIp as offline - not reachable")
+ DeviceStatusManager.updateDeviceStatus(deviceIp, false)
+ }
+ }catch (e: Exception){
+ Timber.tag("NetworkScreenViewModel").d("Error checking device
+ $deviceIp:
+ ${e.message}")
+ DeviceStatusManager.updateDeviceStatus(deviceIp, false)
+ }
}
- )
+ }catch (e: Exception) {
+ Timber.tag("NetworkScreenViewModel").e("Error during periodic ping", e)
}
+ //wait for 30 secs before next ming
+ delay(30000)
}
}
}
-
- fun getDeviceName(wifiAddress: Int) {
- viewModelScope.launch {
- val inetAddress = InetAddress.getByAddress(wifiAddress.addressToByteArray())
- appServer.sendDeviceName(inetAddress)
+ */
+ fun getDeviceName(wifiAddress: Int) {
+ viewModelScope.launch {
+ val inetAddress = InetAddress.getByAddress(wifiAddress.addressToByteArray())
+ appServer.sendDeviceName(inetAddress)
+ }
}
}
}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/viewModel/OnboardingViewModel.kt b/app/src/main/java/com/greybox/projectmesh/viewModel/OnboardingViewModel.kt
new file mode 100644
index 00000000..7e0f3c71
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/viewModel/OnboardingViewModel.kt
@@ -0,0 +1,73 @@
+package com.greybox.projectmesh.viewModel
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import java.util.UUID
+import com.greybox.projectmesh.user.UserRepository
+import android.content.SharedPreferences
+import timber.log.Timber
+
+
+data class OnboardingUiState(
+ val username: String
+)
+
+class OnboardingViewModel(
+ private val userRepository: UserRepository,
+ private val prefs: SharedPreferences,
+ private val localIp: String // Use the local IP here
+) : ViewModel() {
+
+ private val _uiState = MutableStateFlow(OnboardingUiState(username = ""))
+ val uiState = _uiState.asStateFlow()
+
+ fun onUsernameChange(newUsername: String) {
+ _uiState.value = _uiState.value.copy(username = newUsername)
+ }
+
+ fun handleFirstTimeSetup(onComplete: () -> Unit) {
+ viewModelScope.launch {
+ // Generate or retrieve the user's UUID
+ var uuid = prefs.getString("UUID", null)
+ if (uuid.isNullOrEmpty()) {
+ uuid = UUID.randomUUID().toString()
+ prefs.edit().putString("UUID", uuid).apply()
+ }
+ // Insert or update the user with the local IP
+ userRepository.insertOrUpdateUser(
+ uuid = uuid,
+ name = _uiState.value.username,
+ address = localIp
+ )
+ prefs.edit().putString("device_name", _uiState.value.username).apply()
+ prefs.edit().putBoolean("hasRunBefore", true).apply()
+ onComplete()
+ }
+ }
+
+ // In order to Generate Guest Username
+ fun blankUsernameGenerator(onResult: (String) -> Unit) {
+ viewModelScope.launch {
+ val allUsers = userRepository.getAllUsers()
+ val guestUsernames = allUsers.mapNotNull { it.name }
+ .filter { it.startsWith("Guest") }
+
+ val guestNumbers = guestUsernames.mapNotNull { username ->
+ username.removePrefix("Guest").toIntOrNull()
+ }
+
+ val nextGuestNumber = if (guestNumbers.isEmpty()) {
+ 1
+ } else {
+ guestNumbers.maxOrNull()!! + 1
+ }
+
+ val generatedUsername = "Guest$nextGuestNumber"
+ Timber.tag("Username").d("Username = $generatedUsername")
+ onResult(generatedUsername)
+ }
+ }
+}
diff --git a/app/src/main/java/com/greybox/projectmesh/viewModel/PingScreenViewModel.kt b/app/src/main/java/com/greybox/projectmesh/viewModel/PingScreenViewModel.kt
index 67e0242b..0cb87a9f 100644
--- a/app/src/main/java/com/greybox/projectmesh/viewModel/PingScreenViewModel.kt
+++ b/app/src/main/java/com/greybox/projectmesh/viewModel/PingScreenViewModel.kt
@@ -9,15 +9,12 @@ import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import org.kodein.di.DI
import com.greybox.projectmesh.server.AppServer
-import com.ustadmobile.meshrabiya.ext.addressToByteArray
-import com.ustadmobile.meshrabiya.ext.addressToDotNotation
import com.ustadmobile.meshrabiya.ext.requireAddressAsInt
import com.ustadmobile.meshrabiya.vnet.AndroidVirtualNode
import com.ustadmobile.meshrabiya.vnet.VirtualNode
-import kotlinx.coroutines.flow.firstOrNull
-import kotlinx.coroutines.flow.last
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
import org.kodein.di.instance
import java.net.InetAddress
@@ -35,7 +32,11 @@ class PingScreenViewModel(
// _uiState will be updated whenever there is a change in the UI state
private val _uiState = MutableStateFlow(
PingScreenModel(
- deviceName = GlobalApp.DeviceInfoManager.getDeviceName(virtualAddress),
+ deviceName = runBlocking {
+ GlobalApp.GlobalUserRepo.userRepository.getUserByIp(virtualAddress.hostAddress)
+ ?.name
+ ?: "Unknown"
+ },
virtualAddress = virtualAddress
)
)
diff --git a/app/src/main/java/com/greybox/projectmesh/viewModel/SelectDestNodeScreenViewModel.kt b/app/src/main/java/com/greybox/projectmesh/viewModel/SelectDestNodeScreenViewModel.kt
index abe576c7..b1b51708 100644
--- a/app/src/main/java/com/greybox/projectmesh/viewModel/SelectDestNodeScreenViewModel.kt
+++ b/app/src/main/java/com/greybox/projectmesh/viewModel/SelectDestNodeScreenViewModel.kt
@@ -1,7 +1,6 @@
package com.greybox.projectmesh.viewModel
import android.net.Uri
-import android.util.Log
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
@@ -21,6 +20,7 @@ import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.kodein.di.DI
import org.kodein.di.instance
+import timber.log.Timber
import java.net.InetAddress
data class SelectDestNodeScreenModel(
@@ -63,14 +63,14 @@ class SelectDestNodeScreenViewModel(
// convert the ip address to byte array, then convert it to InetAddress object
// which can be used to perform network operation
val inetAddress = InetAddress.getByAddress(address.addressToByteArray())
- Log.d("uri_track_onClickReveiver", "inetAddress: $inetAddress")
+ Timber.tag("uri_track_onClickReveiver").d("inetAddress: $inetAddress")
// update the ui state to reflect that we are contacting the device
_uiState.update { prev ->
prev.copy(
contactingInProgressDevice = address.addressToDotNotation()
)
}
- Log.d("uri_track_onClickReveiver", "sendUris: ${sendUris.toString()}")
+ Timber.tag("uri_track_onClickReveiver").d("sendUris: ${sendUris.toString()}")
// Launch a coroutine in the ViewModel Scope
viewModelScope.launch {
// Switch the coroutine context to Dispatchers.IO for network operations
@@ -79,16 +79,18 @@ class SelectDestNodeScreenViewModel(
sendUris.map { uri ->
async{
try{
- Log.d("uri_track_onClickReveiver_Loop", uri.toString())
+ Timber.tag("uri_track_onClickReveiver_Loop").d(uri.toString())
val response = appServer.addOutgoingTransfer(
uri = uri,
toNode = inetAddress,
)
- Log.d("uri_track_onClickReveiver_Loop", "response: ${response.toString()}")
+ Timber.tag("uri_track_onClickReveiver_Loop").d("response: ${response
+ .toString()}")
true
}
catch (e: Exception){
- Log.e("AppServer", "Exception attempting to send $uri to destination", e)
+ Timber.tag("AppServer").e(e, "Exception attempting to send $uri to " +
+ "destination")
false
}
}
@@ -96,7 +98,7 @@ class SelectDestNodeScreenViewModel(
}
// if any of the transfers were successful, pop back to previous screen
if(transfer.any{it}){
- Log.d("uri_track_onClickReveiver", "popBackWhenDone")
+ Timber.tag("uri_track_onClickReveiver").d("popBackWhenDone")
popBackWhenDone()
}
}
diff --git a/app/src/main/java/com/greybox/projectmesh/viewModel/SendScreenViewModel.kt b/app/src/main/java/com/greybox/projectmesh/viewModel/SendScreenViewModel.kt
index f6aa716a..6c6dc0a8 100644
--- a/app/src/main/java/com/greybox/projectmesh/viewModel/SendScreenViewModel.kt
+++ b/app/src/main/java/com/greybox/projectmesh/viewModel/SendScreenViewModel.kt
@@ -41,7 +41,13 @@ class SendScreenViewModel(
}
}
- fun onFileChosen(uris: List){
+ fun onFileChosen(uris: List){//Can we copy this to the Chat screen model?
onSwitchToSelectDestNode(uris)
}
+
+ fun onDelete(transfer: AppServer.OutgoingTransferInfo){
+ viewModelScope.launch {
+ appServer.removeOutgoingTransfer(transfer.id)
+ }
+ }
}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/views/ChatScreen.kt b/app/src/main/java/com/greybox/projectmesh/views/ChatScreen.kt
deleted file mode 100644
index a91de6ea..00000000
--- a/app/src/main/java/com/greybox/projectmesh/views/ChatScreen.kt
+++ /dev/null
@@ -1,120 +0,0 @@
-package com.greybox.projectmesh.views
-
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.material3.Button
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextField
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalSavedStateRegistryOwner
-import androidx.compose.ui.unit.dp
-import androidx.lifecycle.viewmodel.compose.viewModel
-import com.greybox.projectmesh.GlobalApp
-import com.greybox.projectmesh.ViewModelFactory
-import com.greybox.projectmesh.viewModel.ChatScreenModel
-import com.greybox.projectmesh.viewModel.ChatScreenViewModel
-import com.greybox.projectmesh.viewModel.HomeScreenViewModel
-import com.greybox.projectmesh.viewModel.PingScreenViewModel
-import com.ustadmobile.meshrabiya.ext.addressToDotNotation
-import com.ustadmobile.meshrabiya.mmcp.MmcpOriginatorMessage
-import org.kodein.di.compose.localDI
-import java.net.InetAddress
-import java.text.SimpleDateFormat
-import java.util.Date
-
-@Composable
-fun ChatScreen(
- virtualAddress: InetAddress,
- onClickButton: () -> Unit,
- viewModel: ChatScreenViewModel = viewModel(
- factory = ViewModelFactory(
- di = localDI(),
- owner = LocalSavedStateRegistryOwner.current,
- vmFactory = { di, savedStateHandle -> ChatScreenViewModel(di, savedStateHandle, virtualAddress)},
- defaultArgs = null
- )
- )
-) {
- // declare the UI state, we can use the uiState to access the current state of the viewModel
- val uiState: ChatScreenModel by viewModel.uiState.collectAsState(initial = ChatScreenModel())
- var textMessage by rememberSaveable { mutableStateOf("") }
- Box(modifier = Modifier.fillMaxSize()) {
- Column(modifier = Modifier
- .fillMaxSize()
- .padding(bottom = 72.dp)) {
- DisplayAllMessages(uiState, onClickButton)
- }
- Row(modifier = Modifier
- .fillMaxWidth()
- .align(Alignment.BottomCenter)
- .padding(4.dp)) {
- TextField(modifier = Modifier.weight(3f),
- value = textMessage,
- onValueChange = {
- textMessage = it
- })
- Button(modifier = Modifier.weight(1f), onClick = {
- val message = textMessage.trimEnd()
- if(message.isNotEmpty()) {
- viewModel.sendChatMessage(virtualAddress, message)
- // resets the text field
- textMessage = ""
- }
- }) {
- Text(text = "Send")
- }
- }
- }
-}
-
-@Composable
-fun DisplayAllMessages(uiState: ChatScreenModel, onClickButton: () -> Unit) {
- val context = LocalContext.current
- // display all chat messages
- LazyColumn{
- item{
- Row(modifier = Modifier.fillMaxWidth()){
- Text(modifier = Modifier.weight(3f),
- text = "Device name: ${uiState.deviceName}, IP address: ${uiState.virtualAddress.hostAddress}"
- )
- Button(modifier = Modifier.weight(1f),
- onClick = onClickButton) {
- Text(text = "Ping")
- }
- }
- }
- items( // todo
- items = uiState.allChatMessages
- ){ chatMessage ->
- Spacer(modifier = Modifier.width(4.dp))
- Row(modifier = Modifier.fillMaxWidth()){
- val sender: String = if(chatMessage.sender == "Me")
- "Me"
- else
- (GlobalApp.DeviceInfoManager.getDeviceName(uiState.virtualAddress) ?: "Loading...")
- LongPressCopyableText(
- context = context,
- text = "$sender [${SimpleDateFormat("HH:mm").format(Date(chatMessage.dateReceived))}]: ",
- textCopyable = "${chatMessage.content}",
- textSize = 15
- )
- }
- }
- }
-}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/views/HomeScreen.kt b/app/src/main/java/com/greybox/projectmesh/views/HomeScreen.kt
index 237b859b..e7201360 100644
--- a/app/src/main/java/com/greybox/projectmesh/views/HomeScreen.kt
+++ b/app/src/main/java/com/greybox/projectmesh/views/HomeScreen.kt
@@ -18,15 +18,15 @@ import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.text.BasicText
-import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.Wifi
@@ -90,16 +90,17 @@ import com.ustadmobile.meshrabiya.vnet.wifi.HotspotType
import com.greybox.projectmesh.components.ConnectWifiLauncherResult
import com.greybox.projectmesh.components.ConnectWifiLauncherStatus
import com.greybox.projectmesh.components.meshrabiyaConnectLauncher
+import com.ustadmobile.meshrabiya.log.MNetLogger
@Composable
// We customize the viewModel since we need to inject dependencies
fun HomeScreen(
viewModel: HomeScreenViewModel = viewModel(
- factory = ViewModelFactory(
- di = localDI(),
- owner = LocalSavedStateRegistryOwner.current,
- vmFactory = { di, savedStateHandle -> HomeScreenViewModel(di, savedStateHandle) },
- defaultArgs = null)),
+ factory = ViewModelFactory(
+ di = localDI(),
+ owner = LocalSavedStateRegistryOwner.current,
+ vmFactory = { di, savedStateHandle -> HomeScreenViewModel(di, savedStateHandle) },
+ defaultArgs = null)),
deviceName: String?
)
{
@@ -107,6 +108,7 @@ fun HomeScreen(
val di = localDI()
val uiState: HomeScreenModel by viewModel.uiState.collectAsState(initial = HomeScreenModel())
val node: VirtualNode by di.instance()
+ val logger: MNetLogger by di.instance()
val currConcurrencyKnown = viewModel.concurrencyKnown.collectAsState()
val currConcurrencySupported = viewModel.concurrencySupported.collectAsState()
@@ -161,6 +163,7 @@ fun HomeScreen(
errorMessage = result.exception?.message
}
},
+ logger = logger
)
// Show an error dialog when needed
errorMessage?.let { message ->
@@ -192,6 +195,7 @@ fun StartHomeScreen(
onSetBand: (ConnectBand) -> Unit = { },
onSetHotspotTypeToCreate: (HotspotType) -> Unit = { },
onConnectWifiLauncherResult: (ConnectWifiLauncherResult) -> Unit,
+ logger: MNetLogger
){
val di = localDI()
val barcodeEncoder = remember { BarcodeEncoder() }
@@ -199,18 +203,20 @@ fun StartHomeScreen(
mutableStateOf(ConnectWifiLauncherStatus.INACTIVE)
}
val connectLauncher = meshrabiyaConnectLauncher(
+ node = node,
+ logger = logger,
onStatusChange = {
connectLauncherState = it
},
- node = node,
onResult = onConnectWifiLauncherResult,
)
var userEnteredConnectUri by rememberSaveable { mutableStateOf("") }
val showNoConcurrencyWarning by viewModel.showNoConcurrencyWarning.collectAsState()
val showConcurrencyWarning by viewModel.showConcurrencyWarning.collectAsState()
// connect to other device via connect uri
- fun connect(uri: String): Unit {
+ fun connect(uri: String, logger: MNetLogger): Unit {
try {
+ logger(Log.INFO, "HomeScreen: Scanned link: $uri")
// Parse the link, get the wifi connect configuration.
val hotSpot = MeshrabiyaConnectLink.parseUri(
uri = uri,
@@ -223,15 +229,15 @@ fun StartHomeScreen(
connectLauncher.launch(hotSpot)
}else{
Toast.makeText(context, "Already connected to this device", Toast.LENGTH_SHORT).show()
- Log.d("Connection", "Already connected to this device")
+ logger(Log.INFO,"Already connected to this device")
}
} else {
Toast.makeText(context, "Link doesn't have a connect config", Toast.LENGTH_SHORT).show()
- Log.d("Connection", "Link doesn't have a connect config")
+ logger(Log.WARN, "HomeScreen: Link doesn't have a connect config")
}
} catch (e: Exception) {
Toast.makeText(context, "Invalid Link", Toast.LENGTH_SHORT).show()
- Log.e("Connection", "Invalid Link ${e.message}")
+ logger(Log.WARN, "HomeScreen: Invalid Link", e)
}
}
@@ -240,10 +246,10 @@ fun StartHomeScreen(
// Get the contents of the QR code
val link = result.contents
if (link != null) {
- connect(link)
+ connect(link, logger)
}else{
Toast.makeText(context, "QR Code scan doesn't return a link", Toast.LENGTH_SHORT).show()
- Log.d("Connection", "QR Code scan doesn't return a link")
+ logger(Log.INFO,"QR Code scan doesn't return a link")
}
}
@@ -257,88 +263,84 @@ fun StartHomeScreen(
ConcurrencyWarningDialog(onDismiss = { viewModel.dismissConcurrencyWarning() })
}
- Column(modifier = Modifier.verticalScroll(rememberScrollState())) {
- Column {
- Spacer(modifier = Modifier.height(6.dp))
- // Display the device name and IP
+ // Function to check if Wi-Fi Direct is supported
+ fun isWifiDirectSupported(context: Context): Boolean {
+ return context.packageManager.hasSystemFeature(PackageManager.FEATURE_WIFI_DIRECT)
+ }
+
+ LazyColumn(
+ modifier = Modifier.fillMaxSize(),
+ verticalArrangement = Arrangement.spacedBy(8.dp),
+ ) {
+ item (key = "device_info") {
LongPressCopyableText(
- context = context,
- text = "",
+ context,
+ text = stringResource(id = R.string.device_name) + ": ",
textCopyable = deviceName.toString(),
- textSize = 15,
+ textSize = 14,
padding = 6
)
- Spacer(modifier = Modifier.height(6.dp))
LongPressCopyableText(
- context = context,
+ context,
text = stringResource(id = R.string.ip_address) + ": ",
textCopyable = uiState.localAddress.addressToDotNotation(),
- textSize = 15,
+ textSize = 14,
padding = 6
)
- Spacer(modifier = Modifier.height(12.dp))
- if(uiState.connectBandVisible) {
- Column {
- Text(
- modifier = Modifier.padding(horizontal = 6.dp),
- text = stringResource(id = R.string.band),
- style = MaterialTheme.typography.bodySmall,
- )
- Row(
- modifier = Modifier.padding(horizontal = 6.dp)
- ) {
- uiState.bandMenu.forEach { band ->
- FilterChip(
- selected = uiState.band == band,
- modifier = Modifier.padding(horizontal = 8.dp, vertical = 8.dp),
- onClick = {
- onSetBand(band)
- },
- label = {
- Text(band.toString())
- },
- )
- }
+ }
+
+ item (key = "band_option"){
+ if (uiState.connectBandVisible) {
+ Text(
+ modifier = Modifier.padding(horizontal = 6.dp),
+ text = stringResource(id = R.string.band),
+ style = MaterialTheme.typography.bodySmall,
+ )
+ Row (modifier = Modifier.padding(horizontal = 6.dp)){
+ uiState.bandMenu.forEach { band ->
+ FilterChip(
+ selected = uiState.band == band,
+ modifier = Modifier.padding(horizontal = 8.dp, vertical = 6.dp),
+ onClick = {
+ onSetBand(band)
+ },
+ label = {
+ Text(band.toString())
+ },
+ )
}
}
}
+ }
- // Function to check if Wi-Fi Direct is supported
- fun isWifiDirectSupported(context: Context): Boolean {
- return context.packageManager.hasSystemFeature(PackageManager.FEATURE_WIFI_DIRECT)
- }
+ item (key = "hotspot_type_option") {
if(!uiState.wifiConnectionEnabled) {
val wifiDirectSupported = isWifiDirectSupported(context)
- Column {
- Text(
- modifier = Modifier.padding(horizontal = 6.dp),
- text = stringResource(id = R.string.hotspot_type),
- style = MaterialTheme.typography.bodySmall,
- )
- Row(
- modifier = Modifier.padding(horizontal = 6.dp)
- ) {
- uiState.hotspotTypeMenu.forEach { hotspotType ->
- val isDisabled = (hotspotType == HotspotType.WIFIDIRECT_GROUP && !wifiDirectSupported)
- FilterChip(
- enabled = !isDisabled,
- selected = hotspotType == uiState.hotspotTypeToCreate,
- modifier = Modifier.padding(horizontal = 8.dp, vertical = 8.dp),
- onClick = { onSetHotspotTypeToCreate(hotspotType) },
- label = { Text(hotspotType.toString()) }
- )
- }
+ Text(
+ modifier = Modifier.padding(horizontal = 6.dp),
+ text = stringResource(id = R.string.hotspot_type),
+ style = MaterialTheme.typography.bodySmall,
+ )
+ Row(modifier = Modifier.padding(horizontal = 6.dp)){
+ uiState.hotspotTypeMenu.forEach { hotspotType ->
+ val isDisabled = (hotspotType == HotspotType.WIFIDIRECT_GROUP && !wifiDirectSupported)
+ FilterChip(
+ enabled = !isDisabled,
+ selected = hotspotType == uiState.hotspotTypeToCreate,
+ modifier = Modifier.padding(horizontal = 8.dp, vertical = 8.dp),
+ onClick = { onSetHotspotTypeToCreate(hotspotType) },
+ label = { Text(hotspotType.toString()) }
+ )
}
}
}
- Spacer(modifier = Modifier.height(8.dp))
+ }
+
+ item (key = "start_stop_hotspot_button"){
// Display the "Start Hotspot" button
val stationState = uiState.wifiState?.wifiStationState
if (!uiState.wifiConnectionEnabled) {
- Row(
- modifier = Modifier.fillMaxWidth(),
- horizontalArrangement = Arrangement.Center
- ) {
+ Row{
TransparentButton(
onClick = { onSetIncomingConnectionsEnabled(true) },
modifier = Modifier.padding(4.dp),
@@ -355,10 +357,7 @@ fun StartHomeScreen(
}
// Display the "Stop Hotspot" button
else{
- Row(
- modifier = Modifier.fillMaxWidth(),
- horizontalArrangement = Arrangement.Center
- ) {
+ Row{
TransparentButton(
onClick = {
stopHotspotConfirmationDialog(context) { onConfirm ->
@@ -373,11 +372,12 @@ fun StartHomeScreen(
)
}
}
+ }
+ item(key = "qr_code_view"){
// Generating QR CODE
val connectUri = uiState.connectUri
if (connectUri != null && uiState.wifiConnectionEnabled) {
- Spacer(modifier = Modifier.height(16.dp))
QRCodeView(
connectUri,
barcodeEncoder,
@@ -395,67 +395,62 @@ fun StartHomeScreen(
putExtra(Intent.EXTRA_TEXT, connectUri)
type = "text/plain"
}
-
val shareIntent = Intent.createChooser(sendIntent, null)
context.startActivity(shareIntent)
}, modifier = Modifier.padding(4.dp), enabled = true) {
Text(stringResource(id = R.string.share_connect_uri))
}
}
+ }
+
+ item(key = "connect_via_qr_code") {
+ val stationState = uiState.wifiState?.wifiStationState
// Scan the QR CODE
// If the stationState is not null and its status is INACTIVE,
// It will display the option to connect via a QR code scan.
if (stationState != null){
if (stationState.status == WifiStationState.Status.INACTIVE){
- Column (modifier = Modifier.fillMaxWidth()){
- Spacer(modifier = Modifier.height(12.dp))
- Text(modifier = Modifier.padding(6.dp), text = stringResource(id = R.string.wifi_station_connection), style = TextStyle(fontSize = 16.sp))
- Spacer(modifier = Modifier.height(12.dp))
- Row (modifier = Modifier.fillMaxWidth(),
- horizontalArrangement = Arrangement.Center)
- {
- TransparentButton(onClick = {
- qrScannerLauncher.launch(ScanOptions().setOrientationLocked(false)
- .setPrompt("Scan another device to join the Mesh")
- .setBeepEnabled(true)
- )},
- modifier = Modifier.padding(4.dp),
- text = stringResource(id = R.string.connect_via_qr_code_scan),
- // If the hotspot isn't started, enable the button
- // Else, check if the device supports WiFi STA/AP Concurrency
- // If it does, enable the button. Otherwise, disable it
- enabled = if(!uiState.hotspotStatus)
- true
- else
- currConcurrencySupported.value
- )
- }
- Spacer(modifier = Modifier.height(12.dp))
- Text(modifier = Modifier.padding(6.dp), text = stringResource(id = R.string.instruction))
- Spacer(modifier = Modifier.height(4.dp))
- TextField(
- value = userEnteredConnectUri,
- onValueChange = {
- userEnteredConnectUri = it
- },
- label = { Text(stringResource(id = R.string.prompt_enter_uri)) }
- )
- Spacer(modifier = Modifier.height(4.dp))
- TransparentButton(
- onClick = {
- connect(userEnteredConnectUri)
- },
+ Text(modifier = Modifier.padding(6.dp), text = stringResource(id = R.string.wifi_station_connection), style = TextStyle(fontSize = 16.sp))
+ Spacer(modifier = Modifier.height(12.dp))
+ Row{
+ TransparentButton(onClick = {
+ qrScannerLauncher.launch(ScanOptions().setOrientationLocked(false)
+ .setPrompt("Scan another device to join the Mesh")
+ .setBeepEnabled(true)
+ )},
modifier = Modifier.padding(4.dp),
- text = stringResource(id = R.string.connect_via_entering_connect_uri),
+ text = stringResource(id = R.string.connect_via_qr_code_scan),
// If the hotspot isn't started, enable the button
// Else, check if the device supports WiFi STA/AP Concurrency
// If it does, enable the button. Otherwise, disable it
- enabled = if (!uiState.hotspotStatus)
+ enabled = if(!uiState.hotspotStatus)
true
else
currConcurrencySupported.value
)
}
+ Text(modifier = Modifier.padding(6.dp), text = stringResource(id = R.string.instruction))
+ TextField(
+ value = userEnteredConnectUri,
+ onValueChange = {
+ userEnteredConnectUri = it
+ },
+ label = { Text(stringResource(id = R.string.prompt_enter_uri)) }
+ )
+ TransparentButton(
+ onClick = {
+ connect(userEnteredConnectUri, logger)
+ },
+ modifier = Modifier.padding(4.dp),
+ text = stringResource(id = R.string.connect_via_entering_connect_uri),
+ // If the hotspot isn't started, enable the button
+ // Else, check if the device supports WiFi STA/AP Concurrency
+ // If it does, enable the button. Otherwise, disable it
+ enabled = if (!uiState.hotspotStatus)
+ true
+ else
+ currConcurrencySupported.value
+ )
}
// If the stationState is not INACTIVE, it displays a ListItem that represents
// the current connection status.
@@ -497,21 +492,21 @@ fun StartHomeScreen(
)
}
}
- Spacer(modifier = Modifier.height(10.dp))
- // add a Hotspot status indicator
+ }
+
+ // add a Hotspot status indicator
+ item(key = "hotspot_status_indicator"){
Row(verticalAlignment = Alignment.CenterVertically) {
- Text(modifier = Modifier.padding(6.dp), text = stringResource(id = R.string.hotspot_status) + ": " +
- if (uiState.hotspotStatus) stringResource(
- id = R.string.hotspot_status_online
- ) else stringResource(id = R.string.hotspot_status_offline))
- Spacer(modifier = Modifier.width(8.dp)) // Adds some space between text and dot
+ Text(modifier = Modifier.padding(6.dp),
+ text = stringResource(id = R.string.hotspot_status) + ": " +
+ if (uiState.hotspotStatus) stringResource(
+ id = R.string.hotspot_status_online)
+ else stringResource(id = R.string.hotspot_status_offline))
Box(
- modifier = Modifier
- .size(8.dp)
- .background(
- color = if (uiState.hotspotStatus) Color.Green else Color.Red,
- shape = CircleShape
- )
+ modifier = Modifier.size(8.dp).background(
+ color = if (uiState.hotspotStatus) Color.Green else Color.Red,
+ shape = CircleShape
+ )
)
}
}
diff --git a/app/src/main/java/com/greybox/projectmesh/views/LogScreen.kt b/app/src/main/java/com/greybox/projectmesh/views/LogScreen.kt
new file mode 100644
index 00000000..23b7808a
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/views/LogScreen.kt
@@ -0,0 +1,183 @@
+package com.greybox.projectmesh.views
+
+import android.widget.Toast
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalClipboardManager
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalSavedStateRegistryOwner
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.greybox.projectmesh.MNetLoggerAndroid
+import com.greybox.projectmesh.ViewModelFactory
+import com.greybox.projectmesh.viewModel.LogScreenModel
+import com.greybox.projectmesh.viewModel.LogScreenViewModel
+import com.ustadmobile.meshrabiya.log.MNetLogger
+import org.kodein.di.compose.localDI
+import org.kodein.di.instance
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+@Composable
+fun LogScreen(
+ viewModel: LogScreenViewModel = viewModel(
+ factory = ViewModelFactory(
+ di = localDI(),
+ owner = LocalSavedStateRegistryOwner.current,
+ vmFactory = { di, savedStateHandle -> LogScreenViewModel(di, savedStateHandle) },
+ defaultArgs = null,
+ )
+ )
+){
+ val uiState by viewModel.uiState.collectAsState(initial = LogScreenModel())
+ ShowLogScreen(uiState)
+}
+
+@Composable
+fun ShowLogScreen(
+ uiState: LogScreenModel
+){
+ val context = LocalContext.current
+ val localDi = localDI()
+ val logger: MNetLogger by localDi.instance()
+ val androidLogger = logger as MNetLoggerAndroid
+ val clipboardManager = LocalClipboardManager.current
+ val timeFormatter = remember {
+ SimpleDateFormat("HH:mm:ss.SS", Locale.getDefault())
+ }
+ var selectionMode by remember { mutableStateOf(false) }
+ var selectedLineIds by remember { mutableStateOf(setOf()) }
+
+ Column {
+ if (selectionMode) {
+ Row(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(8.dp),
+ horizontalArrangement = Arrangement.SpaceBetween,
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ TextButton(onClick = {
+ selectedLineIds = uiState.logs.map { it.lineId }.toSet()
+ }) {
+ Text("Select All")
+ }
+ TextButton(onClick = {
+ val selectedLogs = uiState.logs
+ .filter { selectedLineIds.contains(it.lineId) }
+ .joinToString("\n") {
+ "[${timeFormatter.format(Date(it.time))}] ${it.line}"
+ }
+ clipboardManager.setText(AnnotatedString(selectedLogs))
+ Toast.makeText(context, "Logs copied!", Toast.LENGTH_SHORT).show()
+ selectionMode = false
+ selectedLineIds = emptySet()
+ }) {
+ Text("Copy")
+ }
+ TextButton(onClick = {
+ selectionMode = false
+ selectedLineIds = emptySet()
+ }) {
+ Text("Cancel")
+ }
+ }
+ }
+
+ LazyColumn(
+ modifier = Modifier.fillMaxSize()
+ ) {
+ items(
+ items = uiState.logs,
+ key = { it.lineId }
+ ) { logLine ->
+ val formattedTime = timeFormatter.format(Date(logLine.time))
+ val logText = "[${formattedTime}] ${logLine.line}"
+ val isSelected = selectedLineIds.contains(logLine.lineId)
+
+ Row(
+ modifier = Modifier
+ .fillMaxWidth()
+ .padding(horizontal = 8.dp, vertical = 4.dp)
+ .background(
+ color = if (isSelected) MaterialTheme.colorScheme.primary.copy(alpha = 0.2f)
+ else MaterialTheme.colorScheme.surfaceVariant,
+ shape = RoundedCornerShape(8.dp)
+ )
+ .border(
+ width = 1.dp,
+ color = MaterialTheme.colorScheme.outline,
+ shape = RoundedCornerShape(8.dp)
+ )
+ .clip(RoundedCornerShape(8.dp))
+ .pointerInput(Unit) {
+ detectTapGestures(
+ onTap = {
+ if (selectionMode) {
+ selectedLineIds = if (isSelected) {
+ selectedLineIds - logLine.lineId
+ } else {
+ selectedLineIds + logLine.lineId
+ }
+ }
+ },
+ onLongPress = {
+ if (!selectionMode) {
+ selectionMode = true
+ selectedLineIds = setOf(logLine.lineId)
+ }
+ }
+ )
+ },
+ verticalAlignment = Alignment.CenterVertically
+ ) {
+ if (selectionMode) {
+ Checkbox(
+ checked = isSelected,
+ onCheckedChange = { checked ->
+ selectedLineIds = if (checked) {
+ selectedLineIds + logLine.lineId
+ } else {
+ selectedLineIds - logLine.lineId
+ }
+ }
+ )
+ }
+ ListItem(
+ modifier = Modifier.weight(1f),
+ headlineContent = {
+ Text(logText)
+ }
+ )
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/views/NetworkScreen.kt b/app/src/main/java/com/greybox/projectmesh/views/NetworkScreen.kt
index f893981d..6023167f 100644
--- a/app/src/main/java/com/greybox/projectmesh/views/NetworkScreen.kt
+++ b/app/src/main/java/com/greybox/projectmesh/views/NetworkScreen.kt
@@ -1,43 +1,25 @@
package com.greybox.projectmesh.views
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
+
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Image
-import androidx.compose.material.icons.filled.SignalCellular4Bar
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Icon
-import androidx.compose.material3.ListItem
-import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalSavedStateRegistryOwner
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
-import com.greybox.projectmesh.GlobalApp
import com.greybox.projectmesh.ViewModelFactory
-import com.greybox.projectmesh.viewModel.HomeScreenViewModel
import com.greybox.projectmesh.viewModel.NetworkScreenModel
import com.greybox.projectmesh.viewModel.NetworkScreenViewModel
-import com.ustadmobile.meshrabiya.ext.addressToDotNotation
-import com.ustadmobile.meshrabiya.vnet.VirtualNode
import org.kodein.di.compose.localDI
-
+import com.greybox.projectmesh.extension.WifiListItem
+import com.greybox.projectmesh.server.AppServer
+import java.net.InetAddress
+import org.kodein.di.instance
@Composable
fun NetworkScreen(
- onClickNetworkNode: ((nodeAddress: String) -> Unit)? = null,
+ onNodeClick: (String) -> Unit,
viewModel: NetworkScreenViewModel = viewModel(
factory = ViewModelFactory(
di = localDI(),
@@ -47,6 +29,8 @@ fun NetworkScreen(
) {
// declare the UI state, we can use the uiState to access the current state of the viewModel
val uiState: NetworkScreenModel by viewModel.uiState.collectAsState(initial = NetworkScreenModel())
+ val di = localDI()
+ val appServer: AppServer by di.instance()
// display all the connected station
LazyColumn{
@@ -54,72 +38,20 @@ fun NetworkScreen(
items = uiState.allNodes.entries.toList(),
key = {it.key}
){ eachItem ->
- viewModel.getDeviceName(eachItem.key)
- WifiListItem(eachItem.key, eachItem.value, onClickNetworkNode)
+ WifiListItem(
+ wifiAddress = eachItem.key,
+ wifiEntry = eachItem.value,
+ onClick = { ipAddress ->
+ //request user info when clicking
+ val addr = InetAddress.getByName(ipAddress)
+ appServer.requestRemoteUserInfo(addr)
+ appServer.pushUserInfoTo(addr)
+
+ //Navigate to Ping Screen
+ onNodeClick(ipAddress)
+ }
+ )
}
}
}
-@Composable
-// Display a single connected wifi station
-fun WifiListItem(
- wifiAddress: Int,
- wifiEntry: VirtualNode.LastOriginatorMessage,
- onClick: ((nodeAddress: String) -> Unit)? = null,
-){
- val wifiAddressDotNotation = wifiAddress.addressToDotNotation()
- ListItem(
- modifier = Modifier.fillMaxWidth().let{
- if(onClick != null){
- it.clickable(onClick = {
- onClick(wifiAddressDotNotation)
- })
- }
- else{
- it
- }
- },
- leadingContent = {
- // The image icon on the left side
- Icon(
- // replace this image with a custom icon or image
- imageVector = Icons.Default.Image,
- contentDescription = "Profile Picture",
- modifier = Modifier.size(28.dp)
- )
- },
- headlineContent = {
- // obtain the device name according to the ip address
- val device = GlobalApp.DeviceInfoManager.getDeviceName(wifiAddressDotNotation)
- if(device != null){
- Text(text= device, fontWeight = FontWeight.Bold)
- }
- else{
- Text(text = "Loading...", fontWeight = FontWeight.Bold)
- }
- },
- supportingContent = {
- Text(text = wifiAddressDotNotation)
- },
- trailingContent = {
- // The mesh status with signal bars and text
- Row(
- verticalAlignment = Alignment.CenterVertically
- ) {
- Icon(
- imageVector = Icons.Default.SignalCellular4Bar,
- contentDescription = "Mesh Signal Strength",
- modifier = Modifier.size(24.dp)
- )
- Spacer(modifier = Modifier.width(4.dp))
- Column{
- Text(text = "Mesh status")
- Spacer(modifier = Modifier.width(4.dp))
- Text("Ping: ${wifiEntry.originatorMessage.pingTimeSum}ms "
- + "Hops: ${wifiEntry.hopCount} ")
- }
- }
- }
- )
- HorizontalDivider()
-}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/views/OnboardingScreen.kt b/app/src/main/java/com/greybox/projectmesh/views/OnboardingScreen.kt
new file mode 100644
index 00000000..364cfc58
--- /dev/null
+++ b/app/src/main/java/com/greybox/projectmesh/views/OnboardingScreen.kt
@@ -0,0 +1,81 @@
+package com.greybox.projectmesh.views
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextField
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.greybox.projectmesh.GlobalApp
+import com.greybox.projectmesh.extension.getLocalIpFromDI
+import com.greybox.projectmesh.viewModel.OnboardingViewModel
+import org.kodein.di.compose.localDI
+
+@Composable
+fun OnboardingScreen(
+ onComplete: () -> Unit
+) {
+ // Retrieve DI instance
+ val di = localDI()
+ // Get the local IP from DI using our helper function
+ val localIp = getLocalIpFromDI(di)
+
+ // Create a custom ViewModelProvider.Factory that passes the local IP to OnboardingViewModel
+ val factory = remember {
+ object : ViewModelProvider.Factory {
+ override fun create(modelClass: Class): T {
+ if (modelClass.isAssignableFrom(OnboardingViewModel::class.java)) {
+ @Suppress("UNCHECKED_CAST")
+ return OnboardingViewModel(
+ userRepository = GlobalApp.GlobalUserRepo.userRepository,
+ prefs = GlobalApp.GlobalUserRepo.prefs,
+ localIp = localIp // pass the local IP here
+ ) as T
+ }
+ throw IllegalArgumentException("Unknown ViewModel class")
+ }
+ }
+ }
+
+ // Obtain the OnboardingViewModel using the custom factory
+ val onboardingViewModel: OnboardingViewModel = viewModel(factory = factory)
+ val uiState by onboardingViewModel.uiState.collectAsState()
+
+ // Build your UI
+ Column(modifier = Modifier.padding(16.dp)) {
+ Text("Welcome to Project Mesh!")
+ Spacer(modifier = Modifier.height(16.dp))
+ Text("Please set your username:")
+ TextField(
+ value = uiState.username,
+ onValueChange = { newValue -> onboardingViewModel.onUsernameChange(newValue) }
+ )
+ Spacer(modifier = Modifier.height(16.dp))
+ Button(onClick = {
+ // Check if the username is null or blank
+ if (uiState.username.isNullOrBlank()) {
+ onboardingViewModel.blankUsernameGenerator{ generatedName ->
+ onboardingViewModel.onUsernameChange(generatedName)
+
+ onboardingViewModel.handleFirstTimeSetup { onComplete() }
+ }
+ } else {
+ onboardingViewModel.handleFirstTimeSetup { onComplete() }
+ }
+
+ onboardingViewModel.handleFirstTimeSetup { onComplete() }
+ }) {
+ Text("Next")
+ }
+ }
+}
diff --git a/app/src/main/java/com/greybox/projectmesh/views/PingScreen.kt b/app/src/main/java/com/greybox/projectmesh/views/PingScreen.kt
index aefa7cf4..37bcdb16 100644
--- a/app/src/main/java/com/greybox/projectmesh/views/PingScreen.kt
+++ b/app/src/main/java/com/greybox/projectmesh/views/PingScreen.kt
@@ -17,7 +17,6 @@ import androidx.compose.ui.platform.LocalSavedStateRegistryOwner
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import com.greybox.projectmesh.ViewModelFactory
-import com.greybox.projectmesh.viewModel.ChatScreenViewModel
import com.greybox.projectmesh.viewModel.PingScreenModel
import com.greybox.projectmesh.viewModel.PingScreenViewModel
import com.ustadmobile.meshrabiya.ext.addressToDotNotation
diff --git a/app/src/main/java/com/greybox/projectmesh/views/ReceiveScreen.kt b/app/src/main/java/com/greybox/projectmesh/views/ReceiveScreen.kt
index 336208ca..2bde0ac9 100644
--- a/app/src/main/java/com/greybox/projectmesh/views/ReceiveScreen.kt
+++ b/app/src/main/java/com/greybox/projectmesh/views/ReceiveScreen.kt
@@ -1,12 +1,14 @@
package com.greybox.projectmesh.views
+import android.content.ContentValues
import android.content.Context
import android.content.Intent
import android.content.SharedPreferences
import android.net.Uri
+import android.os.Build
import android.os.Environment
import android.provider.DocumentsContract
-import android.util.Log
+import android.provider.MediaStore
import android.webkit.MimeTypeMap
import android.widget.Toast
import androidx.compose.foundation.clickable
@@ -52,8 +54,8 @@ import org.kodein.di.DI
import org.kodein.di.instance
import java.io.File
import androidx.compose.material3.HorizontalDivider
-import com.greybox.projectmesh.viewModel.PingScreenViewModel
import com.greybox.projectmesh.viewModel.ReceiveScreenModel
+import timber.log.Timber
@Composable
fun ReceiveScreen(
@@ -94,7 +96,7 @@ fun HandleIncomingTransfers(
LaunchedEffect(onAutoFinishChange) {
autoFinishEnabled = settingPref.getBoolean("auto_finish", false)
- Log.d("ReceiveScreen", "autoFinishEnabled: $autoFinishEnabled")
+ Timber.tag("ReceiveScreen").d("autoFinishEnabled: $autoFinishEnabled")
}
LaunchedEffect(autoFinishEnabled, uiState.incomingTransfers) {
if (autoFinishEnabled) {
@@ -147,7 +149,7 @@ fun HandleIncomingTransfers(
LazyColumn(modifier = Modifier.fillMaxSize()) {
items(
items = uiState.incomingTransfers,
- key = {Triple(it.fromHost, it.id, it.requestReceivedTime)}
+ key = {"${it.fromHost.hostAddress}-${it.id}-${it.requestReceivedTime}".hashCode()}
){ transfer ->
ListItem(
modifier = Modifier
@@ -223,7 +225,54 @@ fun onDownload(context: Context, transfer: AppServer.IncomingTransferInfo, uriOr
}
}
+private fun saveFileToMediaStore(context: Context, transfer: AppServer.IncomingTransferInfo) {
+ // Skip for Android 9 and below
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+ return
+ }
+
+ val resolver = context.contentResolver
+ val subDirectory = "Project Mesh"
+ val fullPath = "${Environment.DIRECTORY_DOWNLOADS}/$subDirectory"
+ val contentValues = ContentValues().apply {
+ put(MediaStore.Downloads.DISPLAY_NAME, transfer.name)
+ put(MediaStore.Downloads.MIME_TYPE, "application/octet-stream")
+ put(MediaStore.Downloads.RELATIVE_PATH, fullPath)
+ }
+
+ val uri = resolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, contentValues)
+ if (uri == null) {
+ Toast.makeText(context, "Failed to save file", Toast.LENGTH_LONG).show()
+ return
+ }
+
+ try {
+ resolver.openOutputStream(uri)?.use { outputStream ->
+ transfer.file?.inputStream()?.use { inputStream ->
+ inputStream.copyTo(outputStream)
+ }
+ }
+ Toast.makeText(context,
+ "File saved to: $fullPath",
+ Toast.LENGTH_LONG
+ ).show()
+ } catch (e: Exception) {
+ e.printStackTrace()
+ Toast.makeText(context,
+ "Error saving file: ${e.localizedMessage}",
+ Toast.LENGTH_LONG
+ ).show()
+ }
+}
+
+
private fun saveFileToDefaultPath(context: Context, transfer: AppServer.IncomingTransferInfo, folderPath: String) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+ // Android 10+ → Use MediaStore API
+ saveFileToMediaStore(context, transfer)
+ return
+ }
+ // Below implementation is for Android 9 and below
val directoryFile = File(folderPath)
// Ensure the directory exists
@@ -289,5 +338,4 @@ private fun saveFileToContentUri(context: Context, transfer: AppServer.IncomingT
e.printStackTrace()
Toast.makeText(context, "Error saving file: ${e.localizedMessage}", Toast.LENGTH_LONG).show()
}
-}
-
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/greybox/projectmesh/views/SelectDestNodeScreen.kt b/app/src/main/java/com/greybox/projectmesh/views/SelectDestNodeScreen.kt
index 094061f1..bb893f40 100644
--- a/app/src/main/java/com/greybox/projectmesh/views/SelectDestNodeScreen.kt
+++ b/app/src/main/java/com/greybox/projectmesh/views/SelectDestNodeScreen.kt
@@ -22,7 +22,7 @@ import com.greybox.projectmesh.viewModel.PingScreenViewModel
import com.greybox.projectmesh.viewModel.SelectDestNodeScreenModel
import com.greybox.projectmesh.viewModel.SelectDestNodeScreenViewModel
import org.kodein.di.compose.localDI
-
+import com.greybox.projectmesh.extension.WifiListItem
@Composable
fun SelectDestNodeScreen(
uris: List,
diff --git a/app/src/main/java/com/greybox/projectmesh/views/SendScreen.kt b/app/src/main/java/com/greybox/projectmesh/views/SendScreen.kt
index 5f86f1c7..7293d1a5 100644
--- a/app/src/main/java/com/greybox/projectmesh/views/SendScreen.kt
+++ b/app/src/main/java/com/greybox/projectmesh/views/SendScreen.kt
@@ -3,20 +3,47 @@ package com.greybox.projectmesh.views
import android.net.Uri
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.LinearOutSlowInEasing
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material3.DismissValue
+import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
+import androidx.compose.material3.SwipeToDismiss
+import androidx.compose.material3.SwipeToDismissBox
+import androidx.compose.material3.SwipeToDismissBoxValue
import androidx.compose.material3.Text
+import androidx.compose.material3.rememberSwipeToDismissBoxState
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalSavedStateRegistryOwner
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
@@ -27,6 +54,9 @@ import com.greybox.projectmesh.ViewModelFactory
import com.greybox.projectmesh.ui.theme.TransparentButton
import com.greybox.projectmesh.viewModel.SendScreenModel
import com.greybox.projectmesh.viewModel.SendScreenViewModel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
import org.kodein.di.compose.localDI
@Composable
@@ -55,7 +85,7 @@ fun SendScreen(
Column(modifier = Modifier
.fillMaxSize()
.padding(bottom = 72.dp)) {
- DisplayAllPendingTransfers(uiState)
+ DisplayAllPendingTransfers(viewModel, uiState)
}
TransparentButton(onClick = { openDocumentLauncher.launch(arrayOf("*/*")) },
modifier = Modifier
@@ -67,40 +97,92 @@ fun SendScreen(
}
}
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
@Composable
// Display all the pending transfers
fun DisplayAllPendingTransfers(
+ viewModel: SendScreenViewModel,
uiState: SendScreenModel,
){
+ val coroutineScope = rememberCoroutineScope()
LazyColumn {
items(
items = uiState.outgoingTransfers,
key = { it.id }
) {transfer ->
- ListItem(
- headlineContent = {
- Text(transfer.name)
- },
- supportingContent = {
- Column {
- val byteTransferred: Int = transfer.transferred
- val byteSize: Int = transfer.size
- val toHostAddress = transfer.toHost.hostAddress
- val deviceName = toHostAddress?.let {
- GlobalApp.DeviceInfoManager.getDeviceName(it)
+ var isVisible by remember { mutableStateOf(true) }
+ val swipeState = rememberSwipeToDismissBoxState(
+ confirmValueChange = { dismissValue ->
+ if (dismissValue == SwipeToDismissBoxValue.EndToStart) {
+ coroutineScope.launch {
+ isVisible = false // Start fade-out animation
+ delay(300)
+ viewModel.onDelete(transfer) // Remove item on swipe
}
- if (deviceName != null){
- Text("To ${deviceName}(${toHostAddress})")
- }
- else{
- Text("To Loading...(${toHostAddress})")
- }
- Text(stringResource(id = R.string.status) + ": ${transfer.status}")
- Text(stringResource(id = R.string.send) + " ${autoConvertByte(byteTransferred)} / ${autoConvertByte(byteSize)}")
+ true
+ } else {
+ false
}
}
)
- HorizontalDivider()
+ AnimatedVisibility(
+ visible = isVisible,
+ exit = fadeOut(animationSpec = tween(300)),
+ modifier = Modifier.animateItemPlacement()
+ ){
+ SwipeToDismissBox(
+ state = swipeState,
+ enableDismissFromStartToEnd = false, // Allow swipe only from right to left
+ enableDismissFromEndToStart = true,
+ backgroundContent = {
+ Box(
+ modifier = Modifier
+ .fillMaxSize()
+ .height(64.dp) // Controls the red background size
+ .padding(vertical = 8.dp) // Prevents red from touching top & bottom
+ .background(Color.Red, shape = RoundedCornerShape(12.dp))
+ .border(width = 0.dp, color = Color.Transparent, shape = RoundedCornerShape(12.dp)),
+ contentAlignment = Alignment.CenterEnd
+ ) {
+ Icon(
+ imageVector = Icons.Default.Delete,
+ contentDescription = "Delete",
+ tint = Color.White,
+ modifier = Modifier.size(32.dp).padding(end = 6.dp)
+ )
+ }
+ },
+ content = {
+ ListItem(
+ headlineContent = { Text(transfer.name) },
+ supportingContent = {
+ Column {
+ val byteTransferred: Int = transfer.transferred
+ val byteSize: Int = transfer.size
+ val toHostAddress = transfer.toHost.hostAddress
+ val deviceName = toHostAddress?.let { ipStr ->
+ runBlocking {
+ GlobalApp.GlobalUserRepo.userRepository.getUserByIp(ipStr)?.name
+ }
+ }
+// val deviceName = toHostAddress?.let {
+// GlobalApp.DeviceInfoManager.getDeviceName(it)
+// }
+ if (deviceName != null) {
+ Text("To: ${deviceName} (${toHostAddress})")
+ } else {
+ Text("To: Loading... (${toHostAddress})")
+ }
+ Text(stringResource(id = R.string.status) + ": ${transfer.status}")
+ Text(stringResource(id = R.string.send) + ": ${autoConvertByte(byteTransferred)} / ${autoConvertByte(byteSize)}")
+ }
+ },
+ modifier = Modifier.padding(vertical = 4.dp)
+ )
+ },
+ )
+ HorizontalDivider()
+ }
}
}
}
diff --git a/app/src/main/java/com/greybox/projectmesh/views/SettingsScreen.kt b/app/src/main/java/com/greybox/projectmesh/views/SettingsScreen.kt
index e78410c0..fcf5816b 100644
--- a/app/src/main/java/com/greybox/projectmesh/views/SettingsScreen.kt
+++ b/app/src/main/java/com/greybox/projectmesh/views/SettingsScreen.kt
@@ -2,7 +2,6 @@ package com.greybox.projectmesh.views
import android.content.Intent
import android.content.SharedPreferences
-import android.graphics.Paint.Align
import android.net.Uri
import android.os.Build
import android.widget.Toast
@@ -55,8 +54,6 @@ import com.greybox.projectmesh.ViewModelFactory
import com.greybox.projectmesh.ui.theme.AppTheme
import com.greybox.projectmesh.ui.theme.GradientButton
import com.greybox.projectmesh.ui.theme.GradientLongButton
-import com.greybox.projectmesh.viewModel.HomeScreenViewModel
-import com.greybox.projectmesh.viewModel.SendScreenViewModel
import com.greybox.projectmesh.viewModel.SettingsScreenViewModel
import org.kodein.di.compose.localDI
import org.kodein.di.instance
@@ -266,7 +263,10 @@ fun LanguageSetting(
{
// for Language setting
var langExpanded by remember { mutableStateOf(false) } // Track menu visibility
- val langMenuItems = listOf("en" to "English", "es" to "Español", "cn" to "简体中文") // Menu items
+ val langMenuItems = listOf("en" to "English", "es" to "Español", "cn" to "简体中文", "fr" to
+ "Français") //
+ // Menu
+ // items
val langSelectedOption = langMenuItems.firstOrNull {it.first == currentLanguage}?.second?:"English"
Box()
{
diff --git a/app/src/main/res/drawable/splash_screen.xml b/app/src/main/res/drawable/splash_screen.xml
new file mode 100644
index 00000000..e2151b40
--- /dev/null
+++ b/app/src/main/res/drawable/splash_screen.xml
@@ -0,0 +1,7 @@
+
+
+