mirror of
https://github.com/meshtastic/Meshtastic-Android.git
synced 2026-04-20 22:23:37 +00:00
766 lines
29 KiB
Kotlin
766 lines
29 KiB
Kotlin
package com.geeksville.mesh.model
|
|
|
|
import android.app.Application
|
|
import android.content.Context
|
|
import android.content.SharedPreferences
|
|
import android.net.Uri
|
|
import android.os.RemoteException
|
|
import android.view.Menu
|
|
import androidx.core.content.edit
|
|
import androidx.lifecycle.LiveData
|
|
import androidx.lifecycle.MutableLiveData
|
|
import androidx.lifecycle.ViewModel
|
|
import androidx.lifecycle.asLiveData
|
|
import androidx.lifecycle.viewModelScope
|
|
import com.geeksville.mesh.*
|
|
import com.geeksville.mesh.ChannelProtos.ChannelSettings
|
|
import com.geeksville.mesh.ConfigProtos.Config
|
|
import com.geeksville.mesh.LocalOnlyProtos.LocalConfig
|
|
import com.geeksville.mesh.LocalOnlyProtos.LocalModuleConfig
|
|
import com.geeksville.mesh.android.Logging
|
|
import com.geeksville.mesh.database.MeshLogRepository
|
|
import com.geeksville.mesh.database.PacketRepository
|
|
import com.geeksville.mesh.database.QuickChatActionRepository
|
|
import com.geeksville.mesh.database.entity.MyNodeEntity
|
|
import com.geeksville.mesh.database.entity.NodeEntity
|
|
import com.geeksville.mesh.database.entity.Packet
|
|
import com.geeksville.mesh.database.entity.QuickChatAction
|
|
import com.geeksville.mesh.repository.datastore.RadioConfigRepository
|
|
import com.geeksville.mesh.repository.radio.RadioInterfaceService
|
|
import com.geeksville.mesh.service.MeshService
|
|
import com.geeksville.mesh.util.positionToMeter
|
|
import dagger.hilt.android.lifecycle.HiltViewModel
|
|
import kotlinx.coroutines.Dispatchers
|
|
import kotlinx.coroutines.ExperimentalCoroutinesApi
|
|
import kotlinx.coroutines.flow.MutableStateFlow
|
|
import kotlinx.coroutines.flow.SharingStarted.Companion.Eagerly
|
|
import kotlinx.coroutines.flow.StateFlow
|
|
import kotlinx.coroutines.flow.combine
|
|
import kotlinx.coroutines.flow.filterNotNull
|
|
import kotlinx.coroutines.flow.first
|
|
import kotlinx.coroutines.flow.flatMapLatest
|
|
import kotlinx.coroutines.flow.launchIn
|
|
import kotlinx.coroutines.flow.mapLatest
|
|
import kotlinx.coroutines.flow.onEach
|
|
import kotlinx.coroutines.flow.stateIn
|
|
import kotlinx.coroutines.flow.update
|
|
import kotlinx.coroutines.launch
|
|
import kotlinx.coroutines.withContext
|
|
import org.osmdroid.util.GeoPoint
|
|
import java.io.BufferedWriter
|
|
import java.io.FileNotFoundException
|
|
import java.io.FileWriter
|
|
import java.text.DateFormat
|
|
import java.text.SimpleDateFormat
|
|
import java.util.Date
|
|
import java.util.Locale
|
|
import java.util.concurrent.TimeUnit
|
|
import javax.inject.Inject
|
|
import kotlin.math.roundToInt
|
|
|
|
// Given a human name, strip out the first letter of the first three words and return that as the initials for
|
|
// that user. If the original name is only one word, strip vowels from the original name and if the result is
|
|
// 3 or more characters, use the first three characters. If not, just take the first 3 characters of the
|
|
// original name.
|
|
fun getInitials(nameIn: String): String {
|
|
val nchars = 4
|
|
val minchars = 2
|
|
val name = nameIn.trim()
|
|
val words = name.split(Regex("\\s+")).filter { it.isNotEmpty() }
|
|
|
|
val initials = when (words.size) {
|
|
in 0 until minchars -> {
|
|
val nm = if (name.isNotEmpty()) {
|
|
name.first() + name.drop(1).filterNot { c -> c.lowercase() in "aeiou" }
|
|
} else {
|
|
""
|
|
}
|
|
if (nm.length >= nchars) nm else name
|
|
}
|
|
else -> words.map { it.first() }.joinToString("")
|
|
}
|
|
return initials.take(nchars)
|
|
}
|
|
|
|
/**
|
|
* Builds a [Channel] list from the difference between two [ChannelSettings] lists.
|
|
* Only changes are included in the resulting list.
|
|
*
|
|
* @param new The updated [ChannelSettings] list.
|
|
* @param old The current [ChannelSettings] list (required when disabling unused channels).
|
|
* @return A [Channel] list containing only the modified channels.
|
|
*/
|
|
internal fun getChannelList(
|
|
new: List<ChannelSettings>,
|
|
old: List<ChannelSettings>,
|
|
): List<ChannelProtos.Channel> = buildList {
|
|
for (i in 0..maxOf(old.lastIndex, new.lastIndex)) {
|
|
if (old.getOrNull(i) != new.getOrNull(i)) add(channel {
|
|
role = when (i) {
|
|
0 -> ChannelProtos.Channel.Role.PRIMARY
|
|
in 1..new.lastIndex -> ChannelProtos.Channel.Role.SECONDARY
|
|
else -> ChannelProtos.Channel.Role.DISABLED
|
|
}
|
|
index = i
|
|
settings = new.getOrNull(i) ?: channelSettings { }
|
|
})
|
|
}
|
|
}
|
|
|
|
data class NodesUiState(
|
|
val sort: NodeSortOption = NodeSortOption.LAST_HEARD,
|
|
val filter: String = "",
|
|
val includeUnknown: Boolean = false,
|
|
val gpsFormat: Int = 0,
|
|
val distanceUnits: Int = 0,
|
|
val tempInFahrenheit: Boolean = false,
|
|
val ignoreIncomingList: List<Int> = emptyList(),
|
|
val showDetails: Boolean = false,
|
|
) {
|
|
companion object {
|
|
val Empty = NodesUiState()
|
|
}
|
|
}
|
|
|
|
data class MapState(
|
|
val center: GeoPoint? = null,
|
|
val zoom: Double = 0.0,
|
|
) {
|
|
companion object {
|
|
val Empty = MapState()
|
|
}
|
|
}
|
|
|
|
data class Contact(
|
|
val contactKey: String,
|
|
val shortName: String,
|
|
val longName: String,
|
|
val lastMessageTime: String?,
|
|
val lastMessageText: String?,
|
|
val unreadCount: Int,
|
|
val messageCount: Int,
|
|
val isMuted: Boolean,
|
|
)
|
|
|
|
// return time if within 24 hours, otherwise date
|
|
private fun getShortDate(time: Long): String? {
|
|
val date = if (time != 0L) Date(time) else return null
|
|
val isWithin24Hours = System.currentTimeMillis() - date.time <= TimeUnit.DAYS.toMillis(1)
|
|
|
|
return if (isWithin24Hours) {
|
|
DateFormat.getTimeInstance(DateFormat.SHORT).format(date)
|
|
} else {
|
|
DateFormat.getDateInstance(DateFormat.SHORT).format(date)
|
|
}
|
|
}
|
|
|
|
// return time if within 24 hours, otherwise date/time
|
|
private fun getShortDateTime(time: Long): String {
|
|
val date = Date(time)
|
|
val isWithin24Hours = System.currentTimeMillis() - date.time <= TimeUnit.DAYS.toMillis(1)
|
|
|
|
return if (isWithin24Hours) {
|
|
DateFormat.getTimeInstance(DateFormat.SHORT).format(date)
|
|
} else {
|
|
DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT).format(date)
|
|
}
|
|
}
|
|
|
|
@Suppress("LongParameterList")
|
|
@HiltViewModel
|
|
class UIViewModel @Inject constructor(
|
|
private val app: Application,
|
|
private val nodeDB: NodeDB,
|
|
private val radioConfigRepository: RadioConfigRepository,
|
|
private val radioInterfaceService: RadioInterfaceService,
|
|
private val meshLogRepository: MeshLogRepository,
|
|
private val packetRepository: PacketRepository,
|
|
private val quickChatActionRepository: QuickChatActionRepository,
|
|
private val preferences: SharedPreferences
|
|
) : ViewModel(), Logging {
|
|
|
|
var actionBarMenu: Menu? = null
|
|
val meshService: IMeshService? get() = radioConfigRepository.meshService
|
|
|
|
val bondedAddress get() = radioInterfaceService.getBondedDeviceAddress()
|
|
val selectedBluetooth get() = radioInterfaceService.getDeviceAddress()?.getOrNull(0) == 'x'
|
|
|
|
private val _localConfig = MutableStateFlow<LocalConfig>(LocalConfig.getDefaultInstance())
|
|
val localConfig: StateFlow<LocalConfig> = _localConfig
|
|
val config get() = _localConfig.value
|
|
|
|
private val _moduleConfig = MutableStateFlow<LocalModuleConfig>(LocalModuleConfig.getDefaultInstance())
|
|
val moduleConfig: StateFlow<LocalModuleConfig> = _moduleConfig
|
|
val module get() = _moduleConfig.value
|
|
|
|
private val _channels = MutableStateFlow(channelSet {})
|
|
val channels: StateFlow<AppOnlyProtos.ChannelSet> get() = _channels
|
|
|
|
private val _quickChatActions = MutableStateFlow<List<QuickChatAction>>(emptyList())
|
|
val quickChatActions: StateFlow<List<QuickChatAction>> = _quickChatActions
|
|
|
|
private val _focusedNode = MutableStateFlow<NodeEntity?>(null)
|
|
val focusedNode: StateFlow<NodeEntity?> = _focusedNode
|
|
|
|
private val nodeFilterText = MutableStateFlow("")
|
|
private val nodeSortOption = MutableStateFlow(NodeSortOption.LAST_HEARD)
|
|
private val includeUnknown = MutableStateFlow(false)
|
|
private val showDetails = MutableStateFlow(false)
|
|
|
|
fun setSortOption(sort: NodeSortOption) {
|
|
nodeSortOption.value = sort
|
|
}
|
|
|
|
fun toggleShowDetails() {
|
|
showDetails.value = !showDetails.value
|
|
}
|
|
|
|
fun toggleIncludeUnknown() {
|
|
includeUnknown.value = !includeUnknown.value
|
|
}
|
|
|
|
val nodesUiState: StateFlow<NodesUiState> = combine(
|
|
nodeFilterText,
|
|
nodeSortOption,
|
|
includeUnknown,
|
|
showDetails,
|
|
radioConfigRepository.deviceProfileFlow,
|
|
) { filter, sort, includeUnknown, showDetails, profile ->
|
|
NodesUiState(
|
|
sort = sort,
|
|
filter = filter,
|
|
includeUnknown = includeUnknown,
|
|
gpsFormat = profile.config.display.gpsFormat.number,
|
|
distanceUnits = profile.config.display.units.number,
|
|
tempInFahrenheit = profile.moduleConfig.telemetry.environmentDisplayFahrenheit,
|
|
ignoreIncomingList = profile.config.lora.ignoreIncomingList,
|
|
showDetails = showDetails,
|
|
)
|
|
}.stateIn(
|
|
scope = viewModelScope,
|
|
started = Eagerly,
|
|
initialValue = NodesUiState.Empty,
|
|
)
|
|
|
|
@OptIn(ExperimentalCoroutinesApi::class)
|
|
val nodeList: StateFlow<List<NodeEntity>> = nodesUiState.flatMapLatest { state ->
|
|
nodeDB.getNodes(state.sort, state.filter, state.includeUnknown)
|
|
}.stateIn(
|
|
scope = viewModelScope,
|
|
started = Eagerly,
|
|
initialValue = emptyList(),
|
|
)
|
|
|
|
// hardware info about our local device (can be null)
|
|
val myNodeInfo: StateFlow<MyNodeEntity?> get() = nodeDB.myNodeInfo
|
|
val ourNodeInfo: StateFlow<NodeEntity?> get() = nodeDB.ourNodeInfo
|
|
|
|
val nodesWithPosition get() = nodeDB.nodeDBbyNum.value.values.filter { it.validPosition != null }
|
|
|
|
private val _mapState = MutableStateFlow(MapState.Empty)
|
|
val mapState: StateFlow<MapState> get() = _mapState
|
|
|
|
fun updateMapCenterAndZoom(center: GeoPoint, zoom: Double) =
|
|
_mapState.update { it.copy(center = center, zoom = zoom) }
|
|
|
|
fun getUser(userId: String?) = nodeDB.getUser(userId ?: DataPacket.ID_BROADCAST)
|
|
|
|
private val _snackbarText = MutableLiveData<Any?>(null)
|
|
val snackbarText: LiveData<Any?> get() = _snackbarText
|
|
|
|
init {
|
|
radioConfigRepository.errorMessage.filterNotNull().onEach {
|
|
_snackbarText.value = it
|
|
radioConfigRepository.clearErrorMessage()
|
|
}.launchIn(viewModelScope)
|
|
|
|
radioConfigRepository.localConfigFlow.onEach { config ->
|
|
_localConfig.value = config
|
|
}.launchIn(viewModelScope)
|
|
radioConfigRepository.moduleConfigFlow.onEach { config ->
|
|
_moduleConfig.value = config
|
|
}.launchIn(viewModelScope)
|
|
viewModelScope.launch {
|
|
quickChatActionRepository.getAllActions().collect { actions ->
|
|
_quickChatActions.value = actions
|
|
}
|
|
}
|
|
radioConfigRepository.channelSetFlow.onEach { channelSet ->
|
|
_channels.value = channelSet
|
|
}.launchIn(viewModelScope)
|
|
|
|
debug("ViewModel created")
|
|
}
|
|
|
|
val contactList = combine(
|
|
nodeDB.myNodeInfo,
|
|
packetRepository.getContacts(),
|
|
channels,
|
|
packetRepository.getContactSettings(),
|
|
) { myNodeInfo, contacts, channelSet, settings ->
|
|
val myNodeNum = myNodeInfo?.myNodeNum ?: return@combine emptyList()
|
|
// Add empty channel placeholders (always show Broadcast contacts, even when empty)
|
|
val placeholder = (0 until channelSet.settingsCount).associate { ch ->
|
|
val contactKey = "$ch${DataPacket.ID_BROADCAST}"
|
|
val data = DataPacket(bytes = null, dataType = 1, time = 0L, channel = ch)
|
|
contactKey to Packet(0L, myNodeNum, 1, contactKey, 0L, true, data)
|
|
}
|
|
|
|
(contacts + (placeholder - contacts.keys)).values.map { packet ->
|
|
val data = packet.data
|
|
val contactKey = packet.contact_key
|
|
|
|
// Determine if this is my message (originated on this device)
|
|
val fromLocal = data.from == DataPacket.ID_LOCAL
|
|
val toBroadcast = data.to == DataPacket.ID_BROADCAST
|
|
|
|
// grab usernames from NodeInfo
|
|
val user = getUser(if (fromLocal) data.to else data.from)
|
|
|
|
val shortName = user.shortName
|
|
val longName = if (toBroadcast) {
|
|
channelSet.getChannel(data.channel)?.name ?: app.getString(R.string.channel_name)
|
|
} else {
|
|
user.longName
|
|
}
|
|
|
|
Contact(
|
|
contactKey = contactKey,
|
|
shortName = if (toBroadcast) "${data.channel}" else shortName,
|
|
longName = longName,
|
|
lastMessageTime = getShortDate(data.time),
|
|
lastMessageText = if (fromLocal) data.text else "$shortName: ${data.text}",
|
|
unreadCount = packetRepository.getUnreadCount(contactKey),
|
|
messageCount = packetRepository.getMessageCount(contactKey),
|
|
isMuted = settings[contactKey]?.isMuted == true,
|
|
)
|
|
}
|
|
}.stateIn(
|
|
scope = viewModelScope,
|
|
started = Eagerly,
|
|
initialValue = emptyList(),
|
|
)
|
|
|
|
@OptIn(ExperimentalCoroutinesApi::class)
|
|
fun getMessagesFrom(contactKey: String) = packetRepository.getMessagesFrom(contactKey).mapLatest { list ->
|
|
list.map {
|
|
Message(
|
|
uuid = it.uuid,
|
|
receivedTime = it.received_time,
|
|
user = getUser(it.data.from),
|
|
text = it.data.text.orEmpty(),
|
|
time = getShortDateTime(it.data.time),
|
|
read = it.read,
|
|
status = it.data.status,
|
|
routingError = it.routingError,
|
|
)
|
|
}
|
|
}
|
|
|
|
@OptIn(ExperimentalCoroutinesApi::class)
|
|
val waypoints = packetRepository.getWaypoints().mapLatest { list ->
|
|
list.associateBy { packet -> packet.data.waypoint!!.id }
|
|
.filterValues { it.data.waypoint!!.expire > System.currentTimeMillis() / 1000 }
|
|
}
|
|
|
|
fun generatePacketId(): Int? {
|
|
return try {
|
|
meshService?.packetId
|
|
} catch (ex: RemoteException) {
|
|
errormsg("RemoteException: ${ex.message}")
|
|
return null
|
|
}
|
|
}
|
|
|
|
fun sendMessage(str: String, contactKey: String = "0${DataPacket.ID_BROADCAST}") {
|
|
// contactKey: unique contact key filter (channel)+(nodeId)
|
|
val channel = contactKey[0].digitToIntOrNull()
|
|
val dest = if (channel != null) contactKey.substring(1) else contactKey
|
|
|
|
val p = DataPacket(dest, channel ?: 0, str)
|
|
sendDataPacket(p)
|
|
}
|
|
|
|
fun sendWaypoint(wpt: MeshProtos.Waypoint, contactKey: String = "0${DataPacket.ID_BROADCAST}") {
|
|
// contactKey: unique contact key filter (channel)+(nodeId)
|
|
val channel = contactKey[0].digitToIntOrNull()
|
|
val dest = if (channel != null) contactKey.substring(1) else contactKey
|
|
|
|
val p = DataPacket(dest, channel ?: 0, wpt)
|
|
if (wpt.id != 0) sendDataPacket(p)
|
|
}
|
|
|
|
private fun sendDataPacket(p: DataPacket) {
|
|
try {
|
|
meshService?.send(p)
|
|
} catch (ex: RemoteException) {
|
|
errormsg("Send DataPacket error: ${ex.message}")
|
|
}
|
|
}
|
|
|
|
fun requestTraceroute(destNum: Int) {
|
|
info("Requesting traceroute for '$destNum'")
|
|
try {
|
|
val packetId = meshService?.packetId ?: return
|
|
meshService?.requestTraceroute(packetId, destNum)
|
|
} catch (ex: RemoteException) {
|
|
errormsg("Request traceroute error: ${ex.message}")
|
|
}
|
|
}
|
|
|
|
fun removeNode(nodeNum: Int) = viewModelScope.launch(Dispatchers.IO) {
|
|
info("Removing node '$nodeNum'")
|
|
try {
|
|
val packetId = meshService?.packetId ?: return@launch
|
|
meshService?.removeByNodenum(packetId, nodeNum)
|
|
nodeDB.deleteNode(nodeNum)
|
|
} catch (ex: RemoteException) {
|
|
errormsg("Remove node error: ${ex.message}")
|
|
}
|
|
}
|
|
|
|
fun requestUserInfo(destNum: Int) {
|
|
info("Requesting UserInfo for '$destNum'")
|
|
try {
|
|
meshService?.requestUserInfo(destNum)
|
|
} catch (ex: RemoteException) {
|
|
errormsg("Request NodeInfo error: ${ex.message}")
|
|
}
|
|
}
|
|
|
|
fun requestPosition(destNum: Int, position: Position = Position(0.0, 0.0, 0)) {
|
|
info("Requesting position for '$destNum'")
|
|
try {
|
|
meshService?.requestPosition(destNum, position)
|
|
} catch (ex: RemoteException) {
|
|
errormsg("Request position error: ${ex.message}")
|
|
}
|
|
}
|
|
|
|
fun setMuteUntil(contacts: List<String>, until: Long) = viewModelScope.launch(Dispatchers.IO) {
|
|
packetRepository.setMuteUntil(contacts, until)
|
|
}
|
|
|
|
fun deleteContacts(contacts: List<String>) = viewModelScope.launch(Dispatchers.IO) {
|
|
packetRepository.deleteContacts(contacts)
|
|
}
|
|
|
|
fun deleteMessages(uuidList: List<Long>) = viewModelScope.launch(Dispatchers.IO) {
|
|
packetRepository.deleteMessages(uuidList)
|
|
}
|
|
|
|
fun deleteWaypoint(id: Int) = viewModelScope.launch(Dispatchers.IO) {
|
|
packetRepository.deleteWaypoint(id)
|
|
}
|
|
|
|
fun clearUnreadCount(contact: String, timestamp: Long) = viewModelScope.launch(Dispatchers.IO) {
|
|
packetRepository.clearUnreadCount(contact, timestamp)
|
|
}
|
|
|
|
companion object {
|
|
fun getPreferences(context: Context): SharedPreferences =
|
|
context.getSharedPreferences("ui-prefs", Context.MODE_PRIVATE)
|
|
}
|
|
|
|
// Connection state to our radio device
|
|
val connectionState get() = radioConfigRepository.connectionState.asLiveData()
|
|
fun isConnected() = connectionState.value != MeshService.ConnectionState.DISCONNECTED
|
|
|
|
private val _requestChannelUrl = MutableLiveData<Uri?>(null)
|
|
val requestChannelUrl: LiveData<Uri?> get() = _requestChannelUrl
|
|
|
|
fun setRequestChannelUrl(channelUrl: Uri) {
|
|
_requestChannelUrl.value = channelUrl
|
|
}
|
|
|
|
/**
|
|
* Called immediately after activity observes requestChannelUrl
|
|
*/
|
|
fun clearRequestChannelUrl() {
|
|
_requestChannelUrl.value = null
|
|
}
|
|
|
|
fun showSnackbar(resString: Any) {
|
|
_snackbarText.value = resString
|
|
}
|
|
|
|
/**
|
|
* Called immediately after activity observes [snackbarText]
|
|
*/
|
|
fun clearSnackbarText() {
|
|
_snackbarText.value = null
|
|
}
|
|
|
|
var txEnabled: Boolean
|
|
get() = config.lora.txEnabled
|
|
set(value) {
|
|
updateLoraConfig { it.copy { txEnabled = value } }
|
|
}
|
|
|
|
var region: Config.LoRaConfig.RegionCode
|
|
get() = config.lora.region
|
|
set(value) {
|
|
updateLoraConfig { it.copy { region = value } }
|
|
}
|
|
|
|
var ignoreIncomingList: MutableList<Int>
|
|
get() = config.lora.ignoreIncomingList
|
|
set(value) = updateLoraConfig {
|
|
it.copy {
|
|
ignoreIncoming.clear()
|
|
ignoreIncoming.addAll(value)
|
|
}
|
|
}
|
|
|
|
// managed mode disables all access to configuration
|
|
val isManaged: Boolean get() = config.device.isManaged || config.security.isManaged
|
|
|
|
val myNodeNum get() = myNodeInfo.value?.myNodeNum
|
|
val maxChannels get() = myNodeInfo.value?.maxChannels ?: 8
|
|
|
|
override fun onCleared() {
|
|
super.onCleared()
|
|
debug("ViewModel cleared")
|
|
}
|
|
|
|
private inline fun updateLoraConfig(crossinline body: (Config.LoRaConfig) -> Config.LoRaConfig) {
|
|
val data = body(config.lora)
|
|
setConfig(config { lora = data })
|
|
}
|
|
|
|
// Set the radio config (also updates our saved copy in preferences)
|
|
fun setConfig(config: Config) {
|
|
try {
|
|
meshService?.setConfig(config.toByteArray())
|
|
} catch (ex: RemoteException) {
|
|
errormsg("Set config error:", ex)
|
|
}
|
|
}
|
|
|
|
fun setChannel(channel: ChannelProtos.Channel) {
|
|
try {
|
|
meshService?.setChannel(channel.toByteArray())
|
|
} catch (ex: RemoteException) {
|
|
errormsg("Set channel error:", ex)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the radio config (also updates our saved copy in preferences). By default, this will replace
|
|
* all channels in the existing radio config. Otherwise, it will append all [ChannelSettings] that
|
|
* are unique in [channelSet] to the existing radio config.
|
|
*/
|
|
fun setChannels(channelSet: AppOnlyProtos.ChannelSet, overwrite: Boolean = true) = viewModelScope.launch {
|
|
val newRadioSettings: List<ChannelSettings> = if (overwrite) {
|
|
channelSet.settingsList
|
|
} else {
|
|
// To guarantee consistent ordering, using a LinkedHashSet which iterates through it's
|
|
// entries according to the order an item was *first* inserted.
|
|
// https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-linked-hash-set/
|
|
LinkedHashSet(channels.value.settingsList + channelSet.settingsList).toList()
|
|
}
|
|
|
|
getChannelList(newRadioSettings, channels.value.settingsList).forEach(::setChannel)
|
|
radioConfigRepository.replaceAllSettings(newRadioSettings)
|
|
val newConfig = config { lora = channelSet.loraConfig }
|
|
if (overwrite && config.lora != newConfig.lora) setConfig(newConfig)
|
|
}
|
|
|
|
val provideLocation = object : MutableLiveData<Boolean>(preferences.getBoolean("provide-location", false)) {
|
|
override fun setValue(value: Boolean) {
|
|
super.setValue(value)
|
|
|
|
preferences.edit {
|
|
this.putBoolean("provide-location", value)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun setOwner(name: String) {
|
|
val user = ourNodeInfo.value?.user?.copy {
|
|
longName = name
|
|
shortName = getInitials(name)
|
|
} ?: return
|
|
|
|
try {
|
|
// Note: we use ?. here because we might be running in the emulator
|
|
meshService?.setRemoteOwner(myNodeNum ?: return, user.toByteArray())
|
|
} catch (ex: RemoteException) {
|
|
errormsg("Can't set username on device, is device offline? ${ex.message}")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Write the persisted packet data out to a CSV file in the specified location.
|
|
*/
|
|
fun saveMessagesCSV(uri: Uri) {
|
|
viewModelScope.launch(Dispatchers.Main) {
|
|
// Extract distances to this device from position messages and put (node,SNR,distance) in
|
|
// the file_uri
|
|
val myNodeNum = myNodeNum ?: return@launch
|
|
|
|
// Capture the current node value while we're still on main thread
|
|
val nodes = nodeDB.nodeDBbyNum.value
|
|
|
|
val positionToPos: (MeshProtos.Position?) -> Position? = { meshPosition ->
|
|
meshPosition?.let { Position(it) }.takeIf {
|
|
it?.isValid() == true
|
|
}
|
|
}
|
|
|
|
writeToUri(uri) { writer ->
|
|
val nodePositions = mutableMapOf<Int, MeshProtos.Position?>()
|
|
|
|
writer.appendLine("\"date\",\"time\",\"from\",\"sender name\",\"sender lat\",\"sender long\",\"rx lat\",\"rx long\",\"rx elevation\",\"rx snr\",\"distance\",\"hop limit\",\"payload\"")
|
|
|
|
// Packets are ordered by time, we keep most recent position of
|
|
// our device in localNodePosition.
|
|
val dateFormat = SimpleDateFormat("\"yyyy-MM-dd\",\"HH:mm:ss\"", Locale.getDefault())
|
|
meshLogRepository.getAllLogsInReceiveOrder(Int.MAX_VALUE).first().forEach { packet ->
|
|
// If we get a NodeInfo packet, use it to update our position data (if valid)
|
|
packet.nodeInfo?.let { nodeInfo ->
|
|
positionToPos.invoke(nodeInfo.position)?.let {
|
|
nodePositions[nodeInfo.num] = nodeInfo.position
|
|
}
|
|
}
|
|
|
|
packet.meshPacket?.let { proto ->
|
|
// If the packet contains position data then use it to update, if valid
|
|
packet.position?.let { position ->
|
|
positionToPos.invoke(position)?.let {
|
|
nodePositions[proto.from.takeIf { it != 0 } ?: myNodeNum] = position
|
|
}
|
|
}
|
|
|
|
// Filter out of our results any packet that doesn't report SNR. This
|
|
// is primarily ADMIN_APP.
|
|
if (proto.rxSnr != 0.0f) {
|
|
val rxDateTime = dateFormat.format(packet.received_date)
|
|
val rxFrom = proto.from.toUInt()
|
|
val senderName = nodes[proto.from]?.user?.longName ?: ""
|
|
|
|
// sender lat & long
|
|
val senderPosition = nodePositions[proto.from]
|
|
val senderPos = positionToPos.invoke(senderPosition)
|
|
val senderLat = senderPos?.latitude ?: ""
|
|
val senderLong = senderPos?.longitude ?: ""
|
|
|
|
// rx lat, long, and elevation
|
|
val rxPosition = nodePositions[myNodeNum]
|
|
val rxPos = positionToPos.invoke(rxPosition)
|
|
val rxLat = rxPos?.latitude ?: ""
|
|
val rxLong = rxPos?.longitude ?: ""
|
|
val rxAlt = rxPos?.altitude ?: ""
|
|
val rxSnr = proto.rxSnr
|
|
|
|
// Calculate the distance if both positions are valid
|
|
|
|
val dist = if (senderPos == null || rxPos == null) {
|
|
""
|
|
} else {
|
|
positionToMeter(
|
|
rxPosition!!, // Use rxPosition but only if rxPos was valid
|
|
senderPosition!! // Use senderPosition but only if senderPos was valid
|
|
).roundToInt().toString()
|
|
}
|
|
|
|
val hopLimit = proto.hopLimit
|
|
|
|
val payload = when {
|
|
proto.decoded.portnumValue !in setOf(
|
|
Portnums.PortNum.TEXT_MESSAGE_APP_VALUE,
|
|
Portnums.PortNum.RANGE_TEST_APP_VALUE,
|
|
) -> "<${proto.decoded.portnum}>"
|
|
proto.hasDecoded() -> proto.decoded.payload.toStringUtf8()
|
|
.replace("\"", "\"\"")
|
|
proto.hasEncrypted() -> "${proto.encrypted.size()} encrypted bytes"
|
|
else -> ""
|
|
}
|
|
|
|
// date,time,from,sender name,sender lat,sender long,rx lat,rx long,rx elevation,rx snr,distance,hop limit,payload
|
|
writer.appendLine("$rxDateTime,\"$rxFrom\",\"$senderName\",\"$senderLat\",\"$senderLong\",\"$rxLat\",\"$rxLong\",\"$rxAlt\",\"$rxSnr\",\"$dist\",\"$hopLimit\",\"$payload\"")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private suspend inline fun writeToUri(uri: Uri, crossinline block: suspend (BufferedWriter) -> Unit) {
|
|
withContext(Dispatchers.IO) {
|
|
try {
|
|
app.contentResolver.openFileDescriptor(uri, "wt")?.use { parcelFileDescriptor ->
|
|
FileWriter(parcelFileDescriptor.fileDescriptor).use { fileWriter ->
|
|
BufferedWriter(fileWriter).use { writer ->
|
|
block.invoke(writer)
|
|
}
|
|
}
|
|
}
|
|
} catch (ex: FileNotFoundException) {
|
|
errormsg("Can't write file error: ${ex.message}")
|
|
}
|
|
}
|
|
}
|
|
|
|
fun addQuickChatAction(name: String, value: String, mode: QuickChatAction.Mode) {
|
|
viewModelScope.launch(Dispatchers.Main) {
|
|
val action = QuickChatAction(0, name, value, mode, _quickChatActions.value.size)
|
|
quickChatActionRepository.insert(action)
|
|
}
|
|
}
|
|
|
|
fun deleteQuickChatAction(action: QuickChatAction) {
|
|
viewModelScope.launch(Dispatchers.Main) {
|
|
quickChatActionRepository.delete(action)
|
|
}
|
|
}
|
|
|
|
fun updateQuickChatAction(
|
|
action: QuickChatAction,
|
|
name: String?,
|
|
message: String?,
|
|
mode: QuickChatAction.Mode?
|
|
) {
|
|
viewModelScope.launch(Dispatchers.Main) {
|
|
val newAction = QuickChatAction(
|
|
action.uuid,
|
|
name ?: action.name,
|
|
message ?: action.message,
|
|
mode ?: action.mode,
|
|
action.position
|
|
)
|
|
quickChatActionRepository.update(newAction)
|
|
}
|
|
}
|
|
|
|
fun updateActionPositions(actions: List<QuickChatAction>) {
|
|
viewModelScope.launch(Dispatchers.Main) {
|
|
for (position in actions.indices) {
|
|
quickChatActionRepository.setItemPosition(actions[position].uuid, position)
|
|
}
|
|
}
|
|
}
|
|
|
|
val tracerouteResponse: LiveData<String?>
|
|
get() = radioConfigRepository.tracerouteResponse.asLiveData()
|
|
|
|
fun clearTracerouteResponse() {
|
|
radioConfigRepository.clearTracerouteResponse()
|
|
}
|
|
|
|
private val _currentTab = MutableLiveData(0)
|
|
val currentTab: LiveData<Int> get() = _currentTab
|
|
|
|
fun setCurrentTab(tab: Int) {
|
|
_currentTab.value = tab
|
|
}
|
|
|
|
fun focusUserNode(node: NodeEntity?) {
|
|
_currentTab.value = 1
|
|
_focusedNode.value = node
|
|
}
|
|
|
|
fun setNodeFilterText(text: String) {
|
|
nodeFilterText.value = text
|
|
}
|
|
}
|