1018 lines
50 KiB
Kotlin
1018 lines
50 KiB
Kotlin
package com.rosetta.messenger
|
||
|
||
import android.Manifest
|
||
import android.content.pm.PackageManager
|
||
import android.os.Build
|
||
import android.os.Bundle
|
||
import androidx.activity.compose.rememberLauncherForActivityResult
|
||
import androidx.activity.compose.setContent
|
||
import androidx.activity.enableEdgeToEdge
|
||
import androidx.activity.result.contract.ActivityResultContracts
|
||
import androidx.compose.animation.*
|
||
import androidx.compose.animation.core.tween
|
||
import androidx.compose.foundation.background
|
||
import androidx.compose.foundation.isSystemInDarkTheme
|
||
import androidx.compose.foundation.layout.Box
|
||
import androidx.compose.foundation.layout.fillMaxSize
|
||
import androidx.compose.material3.Surface
|
||
import androidx.compose.runtime.*
|
||
import androidx.compose.ui.Modifier
|
||
import androidx.compose.ui.graphics.Color
|
||
import androidx.compose.ui.platform.LocalContext
|
||
import androidx.core.content.ContextCompat
|
||
import androidx.fragment.app.FragmentActivity
|
||
import androidx.lifecycle.lifecycleScope
|
||
import com.google.firebase.FirebaseApp
|
||
import com.google.firebase.messaging.FirebaseMessaging
|
||
import com.rosetta.messenger.data.AccountManager
|
||
import com.rosetta.messenger.data.DecryptedAccount
|
||
import com.rosetta.messenger.data.PreferencesManager
|
||
import com.rosetta.messenger.data.RecentSearchesManager
|
||
import com.rosetta.messenger.database.RosettaDatabase
|
||
import com.rosetta.messenger.network.PacketPushNotification
|
||
import com.rosetta.messenger.network.ProtocolManager
|
||
import com.rosetta.messenger.network.ProtocolState
|
||
import com.rosetta.messenger.network.PushNotificationAction
|
||
import com.rosetta.messenger.network.SearchUser
|
||
import com.rosetta.messenger.repository.AvatarRepository
|
||
import com.rosetta.messenger.ui.auth.AccountInfo
|
||
import com.rosetta.messenger.ui.auth.AuthFlow
|
||
import com.rosetta.messenger.ui.chats.ChatDetailScreen
|
||
import com.rosetta.messenger.ui.chats.ChatsListScreen
|
||
import com.rosetta.messenger.ui.chats.RequestsListScreen
|
||
import com.rosetta.messenger.ui.chats.SearchScreen
|
||
import com.rosetta.messenger.ui.components.OptimizedEmojiCache
|
||
import com.rosetta.messenger.ui.components.SwipeBackContainer
|
||
import com.rosetta.messenger.ui.crashlogs.CrashLogsScreen
|
||
import com.rosetta.messenger.ui.onboarding.OnboardingScreen
|
||
import com.rosetta.messenger.ui.settings.BackupScreen
|
||
import com.rosetta.messenger.ui.settings.BiometricEnableScreen
|
||
import com.rosetta.messenger.ui.settings.OtherProfileScreen
|
||
import com.rosetta.messenger.ui.settings.ProfileScreen
|
||
import com.rosetta.messenger.ui.settings.SafetyScreen
|
||
import com.rosetta.messenger.ui.settings.ThemeScreen
|
||
import com.rosetta.messenger.ui.settings.UpdatesScreen
|
||
import com.rosetta.messenger.ui.splash.SplashScreen
|
||
import com.rosetta.messenger.ui.theme.RosettaAndroidTheme
|
||
import java.text.SimpleDateFormat
|
||
import java.util.Date
|
||
import java.util.Locale
|
||
import kotlinx.coroutines.delay
|
||
import kotlinx.coroutines.launch
|
||
|
||
class MainActivity : FragmentActivity() {
|
||
private lateinit var preferencesManager: PreferencesManager
|
||
private lateinit var accountManager: AccountManager
|
||
|
||
companion object {
|
||
private const val TAG = "MainActivity"
|
||
|
||
// 🔔 FCM Логи для отображения в UI
|
||
private val _fcmLogs = mutableStateListOf<String>()
|
||
val fcmLogs: List<String>
|
||
get() = _fcmLogs
|
||
|
||
fun addFcmLog(message: String) {
|
||
val timestamp = SimpleDateFormat("HH:mm:ss", Locale.getDefault()).format(Date())
|
||
_fcmLogs.add(0, "[$timestamp] $message") // Добавляем в начало списка
|
||
// Ограничиваем количество логов
|
||
if (_fcmLogs.size > 20) {
|
||
_fcmLogs.removeAt(_fcmLogs.size - 1)
|
||
}
|
||
}
|
||
|
||
fun clearFcmLogs() {
|
||
_fcmLogs.clear()
|
||
}
|
||
}
|
||
|
||
override fun onCreate(savedInstanceState: Bundle?) {
|
||
super.onCreate(savedInstanceState)
|
||
enableEdgeToEdge()
|
||
|
||
preferencesManager = PreferencesManager(this)
|
||
accountManager = AccountManager(this)
|
||
RecentSearchesManager.init(this)
|
||
|
||
// 🔥 Инициализируем ProtocolManager для обработки онлайн статусов
|
||
ProtocolManager.initialize(this)
|
||
|
||
// 🔔 Инициализируем Firebase для push-уведомлений
|
||
initializeFirebase()
|
||
|
||
// 🔥 Помечаем что приложение в foreground
|
||
com.rosetta.messenger.push.RosettaFirebaseMessagingService.isAppInForeground = true
|
||
|
||
// 📱 Предзагружаем эмодзи в фоне для мгновенного открытия пикера
|
||
// Используем новый оптимизированный кэш
|
||
OptimizedEmojiCache.preload(this)
|
||
|
||
setContent { // 🔔 Запрос разрешения на уведомления для Android 13+
|
||
val notificationPermissionLauncher =
|
||
rememberLauncherForActivityResult(
|
||
contract = ActivityResultContracts.RequestPermission(),
|
||
onResult = { isGranted -> }
|
||
)
|
||
|
||
// Запрашиваем разрешение при первом запуске (Android 13+)
|
||
LaunchedEffect(Unit) {
|
||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
|
||
val hasPermission =
|
||
ContextCompat.checkSelfPermission(
|
||
this@MainActivity,
|
||
Manifest.permission.POST_NOTIFICATIONS
|
||
) == PackageManager.PERMISSION_GRANTED
|
||
|
||
if (!hasPermission) {
|
||
notificationPermissionLauncher.launch(
|
||
Manifest.permission.POST_NOTIFICATIONS
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
val scope = rememberCoroutineScope()
|
||
val themeMode by preferencesManager.themeMode.collectAsState(initial = "dark")
|
||
val systemInDarkTheme = isSystemInDarkTheme()
|
||
val isDarkTheme =
|
||
when (themeMode) {
|
||
"light" -> false
|
||
"dark" -> true
|
||
"auto" -> systemInDarkTheme
|
||
else -> true
|
||
}
|
||
val isLoggedIn by accountManager.isLoggedIn.collectAsState(initial = null)
|
||
var showSplash by remember { mutableStateOf(true) }
|
||
var showOnboarding by remember { mutableStateOf(true) }
|
||
var hasExistingAccount by remember { mutableStateOf<Boolean?>(null) }
|
||
var currentAccount by remember { mutableStateOf<DecryptedAccount?>(null) }
|
||
var accountInfoList by remember { mutableStateOf<List<AccountInfo>>(emptyList()) }
|
||
|
||
// Check for existing accounts and build AccountInfo list
|
||
// Also force logout so user always sees unlock screen on app restart
|
||
LaunchedEffect(Unit) {
|
||
accountManager.logout() // Always start logged out
|
||
val accounts = accountManager.getAllAccounts()
|
||
hasExistingAccount = accounts.isNotEmpty()
|
||
accountInfoList =
|
||
accounts.map { account ->
|
||
val shortKey = account.publicKey.take(7)
|
||
val displayName = account.name ?: shortKey
|
||
val initials =
|
||
displayName
|
||
.trim()
|
||
.split(Regex("\\s+"))
|
||
.filter { it.isNotEmpty() }
|
||
.let { words ->
|
||
when {
|
||
words.isEmpty() -> "??"
|
||
words.size == 1 -> words[0].take(2).uppercase()
|
||
else ->
|
||
"${words[0].first()}${words[1].first()}".uppercase()
|
||
}
|
||
}
|
||
AccountInfo(
|
||
id = account.publicKey,
|
||
name = displayName,
|
||
username = account.username ?: "",
|
||
initials = initials,
|
||
publicKey = account.publicKey
|
||
)
|
||
}
|
||
}
|
||
|
||
// Wait for initial load
|
||
if (hasExistingAccount == null) {
|
||
Box(
|
||
modifier =
|
||
Modifier.fillMaxSize()
|
||
.background(
|
||
if (isDarkTheme) Color(0xFF1B1B1B) else Color.White
|
||
)
|
||
)
|
||
return@setContent
|
||
}
|
||
|
||
RosettaAndroidTheme(darkTheme = isDarkTheme, animated = true) {
|
||
Surface(
|
||
modifier = Modifier.fillMaxSize(),
|
||
color = if (isDarkTheme) Color(0xFF1B1B1B) else Color.White
|
||
) {
|
||
AnimatedContent(
|
||
targetState =
|
||
when {
|
||
showSplash -> "splash"
|
||
showOnboarding && hasExistingAccount == false ->
|
||
"onboarding"
|
||
isLoggedIn != true && hasExistingAccount == false ->
|
||
"auth_new"
|
||
isLoggedIn != true && hasExistingAccount == true ->
|
||
"auth_unlock"
|
||
else -> "main"
|
||
},
|
||
transitionSpec = {
|
||
fadeIn(animationSpec = tween(600)) togetherWith
|
||
fadeOut(animationSpec = tween(600))
|
||
},
|
||
label = "screenTransition"
|
||
) { screen ->
|
||
when (screen) {
|
||
"splash" -> {
|
||
SplashScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
onSplashComplete = { showSplash = false }
|
||
)
|
||
}
|
||
"onboarding" -> {
|
||
OnboardingScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
onThemeToggle = {
|
||
scope.launch {
|
||
val newMode = if (isDarkTheme) "light" else "dark"
|
||
preferencesManager.setThemeMode(newMode)
|
||
}
|
||
},
|
||
onStartMessaging = { showOnboarding = false }
|
||
)
|
||
}
|
||
"auth_new", "auth_unlock" -> {
|
||
AuthFlow(
|
||
isDarkTheme = isDarkTheme,
|
||
hasExistingAccount = screen == "auth_unlock",
|
||
accounts = accountInfoList,
|
||
accountManager = accountManager,
|
||
onAuthComplete = { account ->
|
||
currentAccount = account
|
||
hasExistingAccount = true
|
||
// Save as last logged account
|
||
account?.let {
|
||
accountManager.setLastLoggedPublicKey(it.publicKey)
|
||
}
|
||
|
||
// 📤 Отправляем FCM токен на сервер после успешной
|
||
// аутентификации
|
||
account?.let { sendFcmTokenToServer(it) }
|
||
|
||
// Reload accounts list
|
||
scope.launch {
|
||
val accounts = accountManager.getAllAccounts()
|
||
accountInfoList =
|
||
accounts.map { acc ->
|
||
val shortKey = acc.publicKey.take(7)
|
||
val displayName = acc.name ?: shortKey
|
||
val initials =
|
||
displayName
|
||
.trim()
|
||
.split(Regex("\\s+"))
|
||
.filter {
|
||
it.isNotEmpty()
|
||
}
|
||
.let { words ->
|
||
when {
|
||
words.isEmpty() ->
|
||
"??"
|
||
words.size ==
|
||
1 ->
|
||
words[0]
|
||
.take(
|
||
2
|
||
)
|
||
.uppercase()
|
||
else ->
|
||
"${words[0].first()}${words[1].first()}".uppercase()
|
||
}
|
||
}
|
||
AccountInfo(
|
||
id = acc.publicKey,
|
||
name = displayName,
|
||
username = acc.username ?: "",
|
||
initials = initials,
|
||
publicKey = acc.publicKey
|
||
)
|
||
}
|
||
}
|
||
},
|
||
onLogout = {
|
||
// Set currentAccount to null immediately to prevent UI
|
||
// lag
|
||
currentAccount = null
|
||
scope.launch {
|
||
com.rosetta.messenger.network.ProtocolManager
|
||
.disconnect()
|
||
accountManager.logout()
|
||
}
|
||
}
|
||
)
|
||
}
|
||
"main" -> {
|
||
MainScreen(
|
||
account = currentAccount,
|
||
isDarkTheme = isDarkTheme,
|
||
themeMode = themeMode,
|
||
onToggleTheme = {
|
||
scope.launch {
|
||
val newMode = if (isDarkTheme) "light" else "dark"
|
||
preferencesManager.setThemeMode(newMode)
|
||
}
|
||
},
|
||
onThemeModeChange = { mode ->
|
||
scope.launch { preferencesManager.setThemeMode(mode) }
|
||
},
|
||
onLogout = {
|
||
// Set currentAccount to null immediately to prevent UI
|
||
// lag
|
||
currentAccount = null
|
||
scope.launch {
|
||
com.rosetta.messenger.network.ProtocolManager
|
||
.disconnect()
|
||
accountManager.logout()
|
||
}
|
||
},
|
||
onAccountInfoUpdated = {
|
||
// Reload account list when profile is updated
|
||
val accounts = accountManager.getAllAccounts()
|
||
accountInfoList =
|
||
accounts.map { acc ->
|
||
val shortKey = acc.publicKey.take(7)
|
||
val displayName = acc.name ?: shortKey
|
||
val initials =
|
||
displayName
|
||
.trim()
|
||
.split(Regex("\\s+"))
|
||
.filter { it.isNotEmpty() }
|
||
.let { words ->
|
||
when {
|
||
words.isEmpty() ->
|
||
"??"
|
||
words.size == 1 ->
|
||
words[0]
|
||
.take(
|
||
2
|
||
)
|
||
.uppercase()
|
||
else ->
|
||
"${words[0].first()}${words[1].first()}".uppercase()
|
||
}
|
||
}
|
||
AccountInfo(
|
||
id = acc.publicKey,
|
||
name = displayName,
|
||
username = acc.username ?: "",
|
||
initials = initials,
|
||
publicKey = acc.publicKey
|
||
)
|
||
}
|
||
}
|
||
)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
override fun onResume() {
|
||
super.onResume()
|
||
// 🔥 Приложение стало видимым - отключаем уведомления
|
||
com.rosetta.messenger.push.RosettaFirebaseMessagingService.isAppInForeground = true
|
||
}
|
||
|
||
override fun onPause() {
|
||
super.onPause()
|
||
// 🔥 Приложение ушло в background - включаем уведомления
|
||
com.rosetta.messenger.push.RosettaFirebaseMessagingService.isAppInForeground = false
|
||
}
|
||
|
||
/** 🔔 Инициализация Firebase Cloud Messaging */
|
||
private fun initializeFirebase() {
|
||
try {
|
||
addFcmLog("🔔 Инициализация Firebase...")
|
||
// Инициализируем Firebase
|
||
FirebaseApp.initializeApp(this)
|
||
addFcmLog("✅ Firebase инициализирован")
|
||
|
||
// Получаем FCM токен
|
||
addFcmLog("📲 Запрос FCM токена...")
|
||
FirebaseMessaging.getInstance().token.addOnCompleteListener { task ->
|
||
if (!task.isSuccessful) {
|
||
addFcmLog("❌ Ошибка получения токена: ${task.exception?.message}")
|
||
return@addOnCompleteListener
|
||
}
|
||
|
||
val token = task.result
|
||
|
||
if (token != null) {
|
||
val shortToken = "${token.take(12)}...${token.takeLast(8)}"
|
||
addFcmLog("✅ FCM токен получен: $shortToken")
|
||
// Сохраняем токен локально
|
||
saveFcmToken(token)
|
||
addFcmLog("💾 Токен сохранен локально")
|
||
} else {
|
||
addFcmLog("⚠️ Токен пустой")
|
||
}
|
||
|
||
// Токен будет отправлен на сервер после успешной аутентификации
|
||
// (см. вызов sendFcmTokenToServer в onAccountLogin)
|
||
}
|
||
} catch (e: Exception) {
|
||
addFcmLog("❌ Ошибка Firebase: ${e.message}")
|
||
}
|
||
}
|
||
|
||
/** Сохранить FCM токен в SharedPreferences */
|
||
private fun saveFcmToken(token: String) {
|
||
val prefs = getSharedPreferences("rosetta_prefs", MODE_PRIVATE)
|
||
prefs.edit().putString("fcm_token", token).apply()
|
||
}
|
||
|
||
/**
|
||
* Отправить FCM токен на сервер Вызывается после успешной аутентификации, когда аккаунт уже
|
||
* расшифрован
|
||
*/
|
||
private fun sendFcmTokenToServer(account: DecryptedAccount) {
|
||
lifecycleScope.launch {
|
||
try {
|
||
val prefs = getSharedPreferences("rosetta_prefs", MODE_PRIVATE)
|
||
val token = prefs.getString("fcm_token", null)
|
||
|
||
if (token == null) {
|
||
addFcmLog("⚠️ Нет сохраненного токена для отправки")
|
||
return@launch
|
||
}
|
||
|
||
val shortToken = "${token.take(12)}...${token.takeLast(8)}"
|
||
addFcmLog("📤 Подготовка к отправке токена на сервер")
|
||
addFcmLog("⏳ Ожидание аутентификации...")
|
||
|
||
// 🔥 КРИТИЧНО: Ждем пока протокол станет AUTHENTICATED
|
||
var waitAttempts = 0
|
||
while (ProtocolManager.state.value != ProtocolState.AUTHENTICATED &&
|
||
waitAttempts < 50) {
|
||
delay(100) // Ждем 100ms
|
||
waitAttempts++
|
||
}
|
||
|
||
if (ProtocolManager.state.value != ProtocolState.AUTHENTICATED) {
|
||
addFcmLog("❌ Таймаут аутентификации (${waitAttempts * 100}ms)")
|
||
return@launch
|
||
}
|
||
|
||
addFcmLog("✅ Аутентификация успешна")
|
||
addFcmLog("📨 Отправка токена: $shortToken")
|
||
|
||
val packet =
|
||
PacketPushNotification().apply {
|
||
this.notificationsToken = token
|
||
this.action = PushNotificationAction.SUBSCRIBE
|
||
}
|
||
|
||
ProtocolManager.send(packet)
|
||
addFcmLog("✅ Пакет отправлен на сервер (ID: 0x10)")
|
||
addFcmLog("🎉 FCM токен успешно зарегистрирован!")
|
||
} catch (e: Exception) {
|
||
addFcmLog("❌ Ошибка отправки: ${e.message}")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Navigation sealed class — replaces ~15 boolean flags with a type-safe navigation stack. ChatsList
|
||
* is always the base layer and is not part of the stack. Each SwipeBackContainer reads a
|
||
* derivedStateOf, so pushing/popping an unrelated screen won't trigger recomposition of other
|
||
* screens.
|
||
*/
|
||
sealed class Screen {
|
||
data object Profile : Screen()
|
||
data object Requests : Screen()
|
||
data object Search : Screen()
|
||
data class ChatDetail(val user: SearchUser) : Screen()
|
||
data class OtherProfile(val user: SearchUser) : Screen()
|
||
data object Updates : Screen()
|
||
data object Theme : Screen()
|
||
data object Safety : Screen()
|
||
data object Backup : Screen()
|
||
data object Logs : Screen()
|
||
data object CrashLogs : Screen()
|
||
data object Biometric : Screen()
|
||
data object Appearance : Screen()
|
||
}
|
||
|
||
@Composable
|
||
fun MainScreen(
|
||
account: DecryptedAccount? = null,
|
||
isDarkTheme: Boolean = true,
|
||
themeMode: String = "dark",
|
||
onToggleTheme: () -> Unit = {},
|
||
onThemeModeChange: (String) -> Unit = {},
|
||
onLogout: () -> Unit = {},
|
||
onAccountInfoUpdated: suspend () -> Unit = {}
|
||
) {
|
||
// Reactive state for account name and username
|
||
var accountName by remember { mutableStateOf(account?.name ?: "Account") }
|
||
val accountPhone =
|
||
account?.publicKey?.take(16)?.let {
|
||
"+${it.take(1)} ${it.substring(1, 4)} ${it.substring(4, 7)}${it.substring(7)}"
|
||
}
|
||
?: "+7 775 9932587"
|
||
val accountPublicKey = account?.publicKey ?: "04c266b98ae5"
|
||
val accountPrivateKey = account?.privateKey ?: ""
|
||
val privateKeyHash = account?.privateKeyHash ?: ""
|
||
|
||
// Username state - загружается из EncryptedAccount
|
||
// Following desktop version pattern: username is stored locally and loaded on app start
|
||
var accountUsername by remember { mutableStateOf("") }
|
||
var reloadTrigger by remember { mutableIntStateOf(0) }
|
||
|
||
// Load username AND name from AccountManager (persisted in DataStore)
|
||
val context = LocalContext.current
|
||
LaunchedEffect(accountPublicKey, reloadTrigger) {
|
||
if (accountPublicKey.isNotBlank() && accountPublicKey != "04c266b98ae5") {
|
||
val accountManager = AccountManager(context)
|
||
val encryptedAccount = accountManager.getAccount(accountPublicKey)
|
||
accountUsername = encryptedAccount?.username ?: ""
|
||
accountName = encryptedAccount?.name ?: accountName
|
||
}
|
||
}
|
||
|
||
// Состояние протокола для передачи в SearchScreen
|
||
val protocolState by ProtocolManager.state.collectAsState()
|
||
|
||
// Перечитать username/name после получения own profile с сервера
|
||
// Аналог Desktop: useUserInformation автоматически обновляет UI при PacketSearch ответе
|
||
LaunchedEffect(protocolState) {
|
||
if (protocolState == ProtocolState.AUTHENTICATED &&
|
||
accountPublicKey.isNotBlank() &&
|
||
accountPublicKey != "04c266b98ae5"
|
||
) {
|
||
delay(2000) // Ждём fetchOwnProfile() → PacketSearch → AccountManager update
|
||
val accountManager = AccountManager(context)
|
||
val encryptedAccount = accountManager.getAccount(accountPublicKey)
|
||
accountUsername = encryptedAccount?.username ?: ""
|
||
accountName = encryptedAccount?.name ?: accountName
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// Navigation stack — sealed class instead of ~15 boolean flags.
|
||
// ChatsList is always the base layer (not in stack).
|
||
// Each derivedStateOf only recomposes its SwipeBackContainer
|
||
// when that specific screen appears/disappears — not on every
|
||
// navigation change. This eliminates the massive recomposition
|
||
// that happened when ANY boolean flag changed.
|
||
// ═══════════════════════════════════════════════════════════
|
||
var navStack by remember { mutableStateOf<List<Screen>>(emptyList()) }
|
||
|
||
// Derived visibility — only triggers recomposition when THIS screen changes
|
||
val isProfileVisible by remember { derivedStateOf { navStack.any { it is Screen.Profile } } }
|
||
val isRequestsVisible by remember { derivedStateOf { navStack.any { it is Screen.Requests } } }
|
||
val isSearchVisible by remember { derivedStateOf { navStack.any { it is Screen.Search } } }
|
||
val chatDetailScreen by remember {
|
||
derivedStateOf { navStack.filterIsInstance<Screen.ChatDetail>().lastOrNull() }
|
||
}
|
||
val selectedUser = chatDetailScreen?.user
|
||
val otherProfileScreen by remember {
|
||
derivedStateOf { navStack.filterIsInstance<Screen.OtherProfile>().lastOrNull() }
|
||
}
|
||
val selectedOtherUser = otherProfileScreen?.user
|
||
val isUpdatesVisible by remember { derivedStateOf { navStack.any { it is Screen.Updates } } }
|
||
val isThemeVisible by remember { derivedStateOf { navStack.any { it is Screen.Theme } } }
|
||
val isSafetyVisible by remember { derivedStateOf { navStack.any { it is Screen.Safety } } }
|
||
val isBackupVisible by remember { derivedStateOf { navStack.any { it is Screen.Backup } } }
|
||
val isLogsVisible by remember { derivedStateOf { navStack.any { it is Screen.Logs } } }
|
||
val isCrashLogsVisible by remember {
|
||
derivedStateOf { navStack.any { it is Screen.CrashLogs } }
|
||
}
|
||
val isBiometricVisible by remember {
|
||
derivedStateOf { navStack.any { it is Screen.Biometric } }
|
||
}
|
||
val isAppearanceVisible by remember {
|
||
derivedStateOf { navStack.any { it is Screen.Appearance } }
|
||
}
|
||
|
||
// Navigation helpers
|
||
fun pushScreen(screen: Screen) {
|
||
navStack = navStack + screen
|
||
}
|
||
fun popScreen() {
|
||
navStack = navStack.dropLast(1)
|
||
}
|
||
fun popProfileAndChildren() {
|
||
navStack =
|
||
navStack.filterNot {
|
||
it is Screen.Profile ||
|
||
it is Screen.Theme ||
|
||
it is Screen.Safety ||
|
||
it is Screen.Backup ||
|
||
it is Screen.Logs ||
|
||
it is Screen.CrashLogs ||
|
||
it is Screen.Biometric ||
|
||
it is Screen.Appearance
|
||
}
|
||
}
|
||
fun popChatAndChildren() {
|
||
navStack = navStack.filterNot { it is Screen.ChatDetail || it is Screen.OtherProfile }
|
||
}
|
||
|
||
// ProfileViewModel для логов
|
||
val profileViewModel: com.rosetta.messenger.ui.settings.ProfileViewModel =
|
||
androidx.lifecycle.viewmodel.compose.viewModel()
|
||
val profileState by profileViewModel.state.collectAsState()
|
||
val chatsListViewModel: com.rosetta.messenger.ui.chats.ChatsListViewModel =
|
||
androidx.lifecycle.viewmodel.compose.viewModel()
|
||
|
||
// Appearance: background blur color preference
|
||
val prefsManager = remember { com.rosetta.messenger.data.PreferencesManager(context) }
|
||
val backgroundBlurColorId by
|
||
prefsManager.backgroundBlurColorId.collectAsState(initial = "avatar")
|
||
val pinnedChats by prefsManager.pinnedChats.collectAsState(initial = emptySet())
|
||
|
||
// AvatarRepository для работы с аватарами
|
||
val avatarRepository =
|
||
remember(accountPublicKey) {
|
||
if (accountPublicKey.isNotBlank() && accountPublicKey != "04c266b98ae5") {
|
||
val database = RosettaDatabase.getDatabase(context)
|
||
AvatarRepository(
|
||
context = context,
|
||
avatarDao = database.avatarDao(),
|
||
currentPublicKey = accountPublicKey
|
||
)
|
||
} else {
|
||
null
|
||
}
|
||
}
|
||
|
||
// Coroutine scope for profile updates
|
||
val mainScreenScope = rememberCoroutineScope()
|
||
|
||
// 🔥 Простая навигация с swipe back
|
||
Box(modifier = Modifier.fillMaxSize()) {
|
||
// Base layer - chats list (всегда видимый, чтобы его было видно при свайпе)
|
||
ChatsListScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
accountName = accountName,
|
||
accountUsername = accountUsername,
|
||
accountPhone = accountPhone,
|
||
accountPublicKey = accountPublicKey,
|
||
accountPrivateKey = accountPrivateKey,
|
||
privateKeyHash = privateKeyHash,
|
||
onToggleTheme = onToggleTheme,
|
||
onProfileClick = { pushScreen(Screen.Profile) },
|
||
onNewGroupClick = {
|
||
// TODO: Navigate to new group
|
||
},
|
||
onContactsClick = {
|
||
// TODO: Navigate to contacts
|
||
},
|
||
onCallsClick = {
|
||
// TODO: Navigate to calls
|
||
},
|
||
onSavedMessagesClick = {
|
||
// Открываем чат с самим собой (Saved Messages)
|
||
pushScreen(
|
||
Screen.ChatDetail(
|
||
SearchUser(
|
||
title = "Saved Messages",
|
||
username = "",
|
||
publicKey = accountPublicKey,
|
||
verified = 0,
|
||
online = 1
|
||
)
|
||
)
|
||
)
|
||
},
|
||
onSettingsClick = { pushScreen(Screen.Profile) },
|
||
onInviteFriendsClick = {
|
||
// TODO: Share invite link
|
||
},
|
||
onSearchClick = { pushScreen(Screen.Search) },
|
||
onRequestsClick = { pushScreen(Screen.Requests) },
|
||
onNewChat = {
|
||
// TODO: Show new chat screen
|
||
},
|
||
onUserSelect = { selectedChatUser ->
|
||
pushScreen(Screen.ChatDetail(selectedChatUser))
|
||
},
|
||
backgroundBlurColorId = backgroundBlurColorId,
|
||
pinnedChats = pinnedChats,
|
||
onTogglePin = { opponentKey ->
|
||
mainScreenScope.launch { prefsManager.togglePinChat(opponentKey) }
|
||
},
|
||
chatsViewModel = chatsListViewModel,
|
||
avatarRepository = avatarRepository,
|
||
onLogout = onLogout
|
||
)
|
||
|
||
SwipeBackContainer(
|
||
isVisible = isRequestsVisible,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Requests } },
|
||
isDarkTheme = isDarkTheme
|
||
) {
|
||
RequestsListScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
chatsViewModel = chatsListViewModel,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Requests } },
|
||
onUserSelect = { selectedRequestUser ->
|
||
navStack =
|
||
navStack.filterNot {
|
||
it is Screen.Requests || it is Screen.ChatDetail
|
||
} + Screen.ChatDetail(selectedRequestUser)
|
||
}
|
||
)
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════
|
||
// Profile Screen — MUST be before sub-screens so it stays
|
||
// visible beneath them during swipe-back animation
|
||
// ═══════════════════════════════════════════════════════════
|
||
SwipeBackContainer(
|
||
isVisible = isProfileVisible,
|
||
onBack = { popProfileAndChildren() },
|
||
isDarkTheme = isDarkTheme
|
||
) {
|
||
// Экран профиля
|
||
ProfileScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
accountName = accountName,
|
||
accountUsername = accountUsername,
|
||
accountPublicKey = accountPublicKey,
|
||
accountPrivateKeyHash = privateKeyHash,
|
||
onBack = { popProfileAndChildren() },
|
||
onSaveProfile = { name, username ->
|
||
accountName = name
|
||
accountUsername = username
|
||
mainScreenScope.launch { onAccountInfoUpdated() }
|
||
},
|
||
onLogout = onLogout,
|
||
onNavigateToTheme = { pushScreen(Screen.Theme) },
|
||
onNavigateToAppearance = { pushScreen(Screen.Appearance) },
|
||
onNavigateToSafety = { pushScreen(Screen.Safety) },
|
||
onNavigateToLogs = { pushScreen(Screen.Logs) },
|
||
onNavigateToCrashLogs = { pushScreen(Screen.CrashLogs) },
|
||
onNavigateToBiometric = { pushScreen(Screen.Biometric) },
|
||
viewModel = profileViewModel,
|
||
avatarRepository = avatarRepository,
|
||
dialogDao = RosettaDatabase.getDatabase(context).dialogDao(),
|
||
backgroundBlurColorId = backgroundBlurColorId
|
||
)
|
||
}
|
||
|
||
// Other screens with swipe back
|
||
SwipeBackContainer(
|
||
isVisible = isBackupVisible,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Backup } + Screen.Safety },
|
||
isDarkTheme = isDarkTheme
|
||
) {
|
||
BackupScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
onBack = {
|
||
navStack = navStack.filterNot { it is Screen.Backup } + Screen.Safety
|
||
},
|
||
onVerifyPassword = { password ->
|
||
// Verify password by trying to decrypt the private key
|
||
try {
|
||
val publicKey = account?.publicKey ?: return@BackupScreen null
|
||
val accountManager = AccountManager(context)
|
||
val encryptedAccount = accountManager.getAccount(publicKey)
|
||
|
||
if (encryptedAccount != null) {
|
||
// Try to decrypt private key with password
|
||
val decryptedPrivateKey =
|
||
com.rosetta.messenger.crypto.CryptoManager
|
||
.decryptWithPassword(
|
||
encryptedAccount.encryptedPrivateKey,
|
||
password
|
||
)
|
||
|
||
if (decryptedPrivateKey != null) {
|
||
// Password is correct, decrypt seed phrase
|
||
com.rosetta.messenger.crypto.CryptoManager.decryptWithPassword(
|
||
encryptedAccount.encryptedSeedPhrase,
|
||
password
|
||
)
|
||
} else {
|
||
null
|
||
}
|
||
} else {
|
||
null
|
||
}
|
||
} catch (e: Exception) {
|
||
null
|
||
}
|
||
}
|
||
)
|
||
}
|
||
|
||
SwipeBackContainer(
|
||
isVisible = isSafetyVisible,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Safety } },
|
||
isDarkTheme = isDarkTheme
|
||
) {
|
||
SafetyScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
accountPublicKey = accountPublicKey,
|
||
accountPrivateKey = accountPrivateKey,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Safety } },
|
||
onBackupClick = {
|
||
navStack = navStack.filterNot { it is Screen.Safety } + Screen.Backup
|
||
},
|
||
onDeleteAccount = {
|
||
// TODO: Implement account deletion
|
||
}
|
||
)
|
||
}
|
||
|
||
SwipeBackContainer(
|
||
isVisible = isThemeVisible,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Theme } },
|
||
isDarkTheme = isDarkTheme
|
||
) {
|
||
ThemeScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
currentThemeMode = themeMode,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Theme } },
|
||
onThemeModeChange = onThemeModeChange
|
||
)
|
||
}
|
||
|
||
SwipeBackContainer(
|
||
isVisible = isAppearanceVisible,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Appearance } },
|
||
isDarkTheme = isDarkTheme
|
||
) {
|
||
com.rosetta.messenger.ui.settings.AppearanceScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
currentBlurColorId = backgroundBlurColorId,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Appearance } },
|
||
onBlurColorChange = { newId ->
|
||
mainScreenScope.launch { prefsManager.setBackgroundBlurColorId(newId) }
|
||
},
|
||
onToggleTheme = onToggleTheme,
|
||
accountPublicKey = accountPublicKey,
|
||
accountName = accountName,
|
||
avatarRepository = avatarRepository
|
||
)
|
||
}
|
||
|
||
SwipeBackContainer(
|
||
isVisible = isUpdatesVisible,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Updates } },
|
||
isDarkTheme = isDarkTheme
|
||
) {
|
||
UpdatesScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Updates } }
|
||
)
|
||
}
|
||
|
||
// 🔒 Lock swipe-back while chat overlays are open (image viewer/editor/media picker/camera).
|
||
var isChatSwipeLocked by remember { mutableStateOf(false) }
|
||
|
||
SwipeBackContainer(
|
||
isVisible = selectedUser != null,
|
||
onBack = { popChatAndChildren() },
|
||
isDarkTheme = isDarkTheme,
|
||
swipeEnabled = !isChatSwipeLocked
|
||
) {
|
||
selectedUser?.let { currentChatUser ->
|
||
// Экран чата
|
||
ChatDetailScreen(
|
||
user = currentChatUser,
|
||
currentUserPublicKey = accountPublicKey,
|
||
currentUserPrivateKey = accountPrivateKey,
|
||
onBack = { popChatAndChildren() },
|
||
onUserProfileClick = { user ->
|
||
// Открываем профиль другого пользователя
|
||
pushScreen(Screen.OtherProfile(user))
|
||
},
|
||
onNavigateToChat = { forwardUser ->
|
||
// 📨 Forward: переход в выбранный чат с полными данными
|
||
navStack =
|
||
navStack.filterNot {
|
||
it is Screen.ChatDetail || it is Screen.OtherProfile
|
||
} + Screen.ChatDetail(forwardUser)
|
||
},
|
||
isDarkTheme = isDarkTheme,
|
||
avatarRepository = avatarRepository,
|
||
onImageViewerChanged = { isLocked -> isChatSwipeLocked = isLocked }
|
||
)
|
||
}
|
||
}
|
||
|
||
SwipeBackContainer(
|
||
isVisible = isSearchVisible,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Search } },
|
||
isDarkTheme = isDarkTheme
|
||
) {
|
||
// Экран поиска
|
||
SearchScreen(
|
||
privateKeyHash = privateKeyHash,
|
||
currentUserPublicKey = accountPublicKey,
|
||
isDarkTheme = isDarkTheme,
|
||
protocolState = protocolState,
|
||
onBackClick = { navStack = navStack.filterNot { it is Screen.Search } },
|
||
onUserSelect = { selectedSearchUser ->
|
||
navStack =
|
||
navStack.filterNot { it is Screen.Search } +
|
||
Screen.ChatDetail(selectedSearchUser)
|
||
}
|
||
)
|
||
}
|
||
|
||
SwipeBackContainer(
|
||
isVisible = isLogsVisible,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Logs } },
|
||
isDarkTheme = isDarkTheme
|
||
) {
|
||
com.rosetta.messenger.ui.settings.ProfileLogsScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
logs = profileState.logs,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Logs } },
|
||
onClearLogs = { profileViewModel.clearLogs() }
|
||
)
|
||
}
|
||
|
||
SwipeBackContainer(
|
||
isVisible = isCrashLogsVisible,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.CrashLogs } },
|
||
isDarkTheme = isDarkTheme
|
||
) {
|
||
CrashLogsScreen(
|
||
onBackClick = { navStack = navStack.filterNot { it is Screen.CrashLogs } }
|
||
)
|
||
}
|
||
|
||
var isOtherProfileSwipeEnabled by remember { mutableStateOf(true) }
|
||
LaunchedEffect(selectedOtherUser?.publicKey) {
|
||
isOtherProfileSwipeEnabled = true
|
||
}
|
||
|
||
SwipeBackContainer(
|
||
isVisible = selectedOtherUser != null,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.OtherProfile } },
|
||
isDarkTheme = isDarkTheme,
|
||
swipeEnabled = isOtherProfileSwipeEnabled
|
||
) {
|
||
selectedOtherUser?.let { currentOtherUser ->
|
||
OtherProfileScreen(
|
||
user = currentOtherUser,
|
||
isDarkTheme = isDarkTheme,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.OtherProfile } },
|
||
onSwipeBackEnabledChanged = { enabled ->
|
||
isOtherProfileSwipeEnabled = enabled
|
||
},
|
||
avatarRepository = avatarRepository,
|
||
currentUserPublicKey = accountPublicKey,
|
||
currentUserPrivateKey = accountPrivateKey
|
||
)
|
||
}
|
||
}
|
||
|
||
// Biometric Enable Screen
|
||
SwipeBackContainer(
|
||
isVisible = isBiometricVisible,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Biometric } },
|
||
isDarkTheme = isDarkTheme
|
||
) {
|
||
val biometricManager = remember {
|
||
com.rosetta.messenger.biometric.BiometricAuthManager(context)
|
||
}
|
||
val biometricPrefs = remember {
|
||
com.rosetta.messenger.biometric.BiometricPreferences(context)
|
||
}
|
||
val activity = context as? FragmentActivity
|
||
|
||
BiometricEnableScreen(
|
||
isDarkTheme = isDarkTheme,
|
||
onBack = { navStack = navStack.filterNot { it is Screen.Biometric } },
|
||
onEnable = { password, onSuccess, onError ->
|
||
if (activity == null) {
|
||
onError("Activity not available")
|
||
return@BiometricEnableScreen
|
||
}
|
||
|
||
biometricManager.encryptPassword(
|
||
activity = activity,
|
||
password = password,
|
||
onSuccess = { encryptedPassword ->
|
||
mainScreenScope.launch {
|
||
biometricPrefs.saveEncryptedPassword(
|
||
accountPublicKey,
|
||
encryptedPassword
|
||
)
|
||
biometricPrefs.enableBiometric()
|
||
onSuccess()
|
||
}
|
||
},
|
||
onError = { error -> onError(error) },
|
||
onCancel = {
|
||
navStack = navStack.filterNot { it is Screen.Biometric }
|
||
}
|
||
)
|
||
}
|
||
)
|
||
}
|
||
}
|
||
}
|