Restored auto app updates + github config updates

Aleks-Levet · Aleks-Levet · commit 67c6aeeb2929 · 2026-06-22T00:08:34.000+02:00
diff --git a/TODO.md b/TODO.md
@@ -31,7 +31,6 @@
 * make the collapsed sections a bit bigger
 
 ## Aleks' fucking todo
-* move code away from mainactivity. now mainactivity is a mess.
 * Modify the BNMV liscence so only the owner can release, and everything that other developers do should be reported to the owner. And state that debug builds should never be released to the public because they are not meant to be used by the users, but only by the developers for developing purposes.
 * when the frequency range is large; they are less reactive for some reason. You don't need to divide the sum of the bins by the frequency range, the size of the frequency range. One of the causes is that the wide frequency ranges are less reactive than the narrow ones, which are usually the bass ones, so we can't really see the trebles.
 * enhance the built-in switches by adding an X (cross) or a done (✅) in them, like the battery guru's settings switches, and also with bouncy animations and nice haptics
@@ -57,6 +56,7 @@
 ---
 
 ## Done
+* move code away from mainactivity. now mainactivity is a mess.
 * use the system navbar padding (fix it again)
 * **Make the haptic amplitude mode resubmit a oneshot haptic all the time, even if it doesn't change!!!** currently it doesn't resubmit when the vibration amplitude doesn't change!
 * make the oneshot duration slightly longer
diff --git a/app/src/main/java/com/better/nothing/music/vizualizer/ui/AuthDialog.kt b/app/src/main/java/com/better/nothing/music/vizualizer/ui/AuthDialog.kt
@@ -25,8 +25,7 @@ import com.better.nothing.music.vizualizer.R
 fun AuthDialog(
     onDismiss: () -> Unit,
     onSignIn: (String, String) -> Unit,
-    onSignUp: (String, String) -> Unit,
-    onGoogleSignIn: () -> Unit
+    onSignUp: (String, String) -> Unit
 ) {
     var email by remember { mutableStateOf("") }
     var password by remember { mutableStateOf("") }
@@ -127,7 +126,6 @@ fun AuthDialog(
 
                 OutlinedButton(
                     onClick = {
-                        onGoogleSignIn()
                         onDismiss()
                     },
                     modifier = Modifier.fillMaxWidth(),
diff --git a/app/src/main/java/com/better/nothing/music/vizualizer/ui/MainViewModel.kt b/app/src/main/java/com/better/nothing/music/vizualizer/ui/MainViewModel.kt
@@ -2,8 +2,10 @@ package com.better.nothing.music.vizualizer.ui
 
 import android.app.Application
 import android.content.Context
+import android.content.Intent
 import android.graphics.Bitmap
 import android.content.pm.PackageManager
+import android.net.Uri
 import android.util.Base64
 import android.util.Log
 import android.widget.Toast
@@ -21,6 +23,7 @@ import com.google.firebase.auth.EmailAuthProvider
 import com.google.firebase.auth.GoogleAuthProvider
 import com.google.firebase.auth.AuthCredential
 import androidx.compose.ui.graphics.Color
+import androidx.core.content.FileProvider
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.*
@@ -29,6 +32,10 @@ import kotlinx.coroutines.withContext
 import kotlinx.coroutines.tasks.await
 import org.json.JSONObject
 import rikka.shizuku.Shizuku
+import java.io.File
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
 import kotlin.math.pow
 import kotlin.math.sqrt
 
@@ -148,8 +155,67 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
         _appUpdateStatus.value = AppUpdateStatus.UpToDate
     }
 
-    fun downloadAndInstallUpdate(apkUrl: String, version: String) {
-        // Mock
+    fun downloadAndInstallUpdate(apkUrl: String, versionName: String) {
+        viewModelScope.launch(Dispatchers.IO) {
+            try {
+                val url = URL(apkUrl)
+                val connection = url.openConnection() as HttpURLConnection
+                connection.connectTimeout = 10000
+                connection.readTimeout = 30000
+
+                if (connection.responseCode == HttpURLConnection.HTTP_OK) {
+                    val fileLength = connection.contentLength
+                    val destinationFile = File(ctx.externalCacheDir, "update_$versionName.apk")
+
+                    connection.inputStream.use { input ->
+                        FileOutputStream(destinationFile).use { output ->
+                            val buffer = ByteArray(8192)
+                            var bytesRead: Int
+                            var totalBytesRead = 0L
+
+                            while (input.read(buffer).also { bytesRead = it } != -1) {
+                                output.write(buffer, 0, bytesRead)
+                                totalBytesRead += bytesRead
+                                if (fileLength > 0) {
+                                    val progress = totalBytesRead.toFloat() / fileLength.toFloat()
+                                    _appUpdateStatus.value = AppUpdateStatus.Downloading(progress)
+                                }
+                            }
+                        }
+                    }
+
+                    withContext(Dispatchers.Main) {
+                        installApk(destinationFile)
+                    }
+                } else {
+                    withContext(Dispatchers.Main) {
+                        Toast.makeText(ctx, "Download failed: ${connection.responseCode}", Toast.LENGTH_SHORT).show()
+                        _appUpdateStatus.value = AppUpdateStatus.Error("Download failed")
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e("MainViewModel", "Download failed", e)
+                withContext(Dispatchers.Main) {
+                    Toast.makeText(ctx, "Download error: ${e.message}", Toast.LENGTH_SHORT).show()
+                    _appUpdateStatus.value = AppUpdateStatus.Error(e.message ?: "Unknown error")
+                }
+            }
+        }
+    }
+
+    private fun installApk(file: File) {
+        try {
+            val uri = FileProvider.getUriForFile(ctx, "${ctx.packageName}.fileprovider", file)
+            val intent = Intent(Intent.ACTION_VIEW).apply {
+                setDataAndType(uri, "application/vnd.android.package-archive")
+                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            }
+            ctx.startActivity(intent)
+        } catch (e: Exception) {
+            Log.e("MainViewModel", "Installation failed", e)
+            Toast.makeText(ctx, "Installation failed: ${e.message}", Toast.LENGTH_SHORT).show()
+        }
     }
 
     private val _isShowingLeaderboard = MutableStateFlow(false)
@@ -194,9 +260,154 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
         }
     }
 
-    fun checkRemoteConfigVersion() { TODO() }
-    fun importZonesConfig(uri: android.net.Uri) { /* Mock */ }
-    fun updateZonesConfig(url: String = "") { /* Mock */ }
+    fun checkRemoteConfigVersion() {
+        viewModelScope.launch(Dispatchers.IO) {
+            try {
+                val url =
+                    URL("https://raw.githubusercontent.com/Aleks-Levet/better-nothing-music-visualizer/main/zones.config?t=${System.currentTimeMillis()}")
+                val connection = url.openConnection() as HttpURLConnection
+                connection.useCaches = false
+                connection.connectTimeout = 5000
+                connection.readTimeout = 5000
+
+                if (connection.responseCode == HttpURLConnection.HTTP_OK) {
+                    val content = connection.inputStream.bufferedReader().use { it.readText() }
+                    val json = JSONObject(content)
+                    val remoteVersion = json.optString("version", "Unknown")
+                    _remoteConfigVersion.value = remoteVersion
+                }
+            } catch (e: Exception) {
+                Log.e("MainViewModel", "Failed to check remote version", e)
+            }
+        }
+    }
+    fun importZonesConfig(uri: Uri) {
+        _configUpdateStatus.value = ConfigUpdateStatus.Updating
+        viewModelScope.launch {
+            announcementRepository.getLatestAnnouncement().collect { announcement ->
+                _latestAnnouncement.value = announcement
+                if (announcement != null) {
+                    val sharedPrefs = ctx.getSharedPreferences("viz_prefs", Context.MODE_PRIVATE)
+                    val lastSeenId = sharedPrefs.getString("last_seen_announcement_id", "")
+                    if (announcement.id.toString() != lastSeenId) {
+                        _showAnnouncementModal.value = true
+                    }
+                }
+            }
+        }
+
+        viewModelScope.launch {
+            try {
+                val success = withContext(Dispatchers.IO) {
+                    val content = ctx.contentResolver.openInputStream(uri)?.bufferedReader()?.use { it.readText() }
+                    if (content == null) return@withContext false
+
+                    // Basic validation
+                    JSONObject(content)
+
+                    val file = File(ctx.filesDir, "zones.config")
+                    file.writeText(content)
+
+                    // Refresh presets (file IO)
+                    refreshPresetsInternal()
+
+                    val newVersion = AudioCaptureService.loadZonesConfigVersion(ctx)
+                    _configVersion.value = newVersion
+                    _remoteConfigVersion.value = null // Clear remote version since we are on local
+
+                    // Force running service to reload its config from disk
+                    MainActivity.serviceStatic?.reloadConfig()
+                    true
+                }
+
+                if (success) {
+                    _configUpdateStatus.value = ConfigUpdateStatus.Success(ctx.getString(R.string.config_import_success))
+                } else {
+                    _configUpdateStatus.value = ConfigUpdateStatus.Error(ctx.getString(R.string.config_import_error))
+                }
+            } catch (e: Exception) {
+                _configUpdateStatus.value = ConfigUpdateStatus.Error(ctx.getString(R.string.config_error_importing, e.message))
+            }
+        }
+    }
+    fun updateZonesConfig() {
+        // 1. Set loading state immediately on Main Thread
+        _configUpdateStatus.value = ConfigUpdateStatus.Updating
+
+        viewModelScope.launch {
+            announcementRepository.getLatestAnnouncement().collect { announcement ->
+                _latestAnnouncement.value = announcement
+                if (announcement != null) {
+                    val sharedPrefs = ctx.getSharedPreferences("viz_prefs", Context.MODE_PRIVATE)
+                    val lastSeenId = sharedPrefs.getString("last_seen_announcement_id", "")
+                    if (announcement.id.toString() != lastSeenId) {
+                        _showAnnouncementModal.value = true
+                    }
+                }
+            }
+        }
+
+        viewModelScope.launch {
+            try {
+                // 2. Perform network/download on IO Thread
+                val success = withContext(Dispatchers.IO) {
+                    performUpdateAction()
+                }
+
+                // 3. Back on Main Thread automatically after withContext
+                if (success) {
+                    _configUpdateStatus.value = ConfigUpdateStatus.Success(ctx.getString(R.string.config_update_success))
+                }
+                // Errors are handled inside performUpdateAction setting the status directly now,
+                // or we could return Result object. To keep it simple with existing code:
+            } catch (e: Exception) {
+                // Catch unexpected errors
+                _configUpdateStatus.value = ConfigUpdateStatus.Error(ctx.getString(R.string.config_error_updating, e.message))
+            }
+        }
+    }
+    private suspend fun performUpdateAction(): Boolean {
+        // This runs on Dispatchers.IO (called from withContext(IO) above)
+        return try {
+            val url = URL("https://raw.githubusercontent.com/Aleks-Levet/better-nothing-music-visualizer/main/zones.config?t=${System.currentTimeMillis()}")
+            val connection = withContext(Dispatchers.IO) {
+                url.openConnection()
+            } as HttpURLConnection
+            connection.useCaches = false
+            connection.connectTimeout = 10000
+            connection.readTimeout = 10000
+
+            if (connection.responseCode == HttpURLConnection.HTTP_OK) {
+                val content = connection.inputStream.bufferedReader().use { it.readText() }
+                // Basic validation
+                JSONObject(content)
+
+                val file = File(ctx.filesDir, "zones.config")
+                file.writeText(content)
+
+                // Refresh presets (file IO)
+                refreshPresetsInternal()
+
+                val newVersion = AudioCaptureService.loadZonesConfigVersion(ctx)
+                _configVersion.value = newVersion
+                _remoteConfigVersion.value = newVersion
+
+                // Force running service to reload its config from disk
+                MainActivity.serviceStatic?.reloadConfig()
+                true
+            } else {
+                withContext(Dispatchers.Main) {
+                    _configUpdateStatus.value = ConfigUpdateStatus.Error(ctx.getString(R.string.config_download_error, connection.responseCode))
+                }
+                false
+            }
+        } catch (e: Exception) {
+            withContext(Dispatchers.Main) {
+                _configUpdateStatus.value = ConfigUpdateStatus.Error(ctx.getString(R.string.config_error_updating, e.message))
+            }
+            false
+        }
+    }
     fun updateProfilePicture(uri: android.net.Uri) {
         val uid = _userId.value ?: return
         viewModelScope.launch {
@@ -353,7 +564,6 @@ class MainViewModel(application: Application) : AndroidViewModel(application) {
     }
 
     val _thanksMessage = MutableStateFlow<String?>(null)
-    val thanksMessage = _thanksMessage.asStateFlow()
     val thanksQueue = mutableListOf<String>()
 
     fun dismissThanksMessage() {
diff --git a/app/src/main/java/com/better/nothing/music/vizualizer/ui/PrimaryScreens/SettingsScreen.kt b/app/src/main/java/com/better/nothing/music/vizualizer/ui/PrimaryScreens/SettingsScreen.kt
@@ -89,7 +89,6 @@ internal fun SettingsScreen(
             onDismiss = { showAuthDialog = false },
             onSignIn = { e, p -> viewModel.signInWithEmail(e, p) },
             onSignUp = { e, p -> viewModel.signUpWithEmail(e, p) },
-            onGoogleSignIn = onGoogleSignIn
         )
     }
 
diff --git a/app/src/main/java/com/better/nothing/music/vizualizer/ui/firebaseFuckery.kt b/app/src/main/java/com/better/nothing/music/vizualizer/ui/firebaseFuckery.kt
@@ -40,7 +40,7 @@ fun launchGoogleSignIn(
             try {
                 val account = task.getResult(Exception::class.java)
                 val credential = GoogleAuthProvider.getCredential(account?.idToken, null)
-                viewModel.linkWithCredential(credential)
+                //viewModel.linkWithCredential(credential)
             } catch (e: Exception) {
                 Toast.makeText(context, "Google sign in failed: ${e.message}", Toast.LENGTH_SHORT).show()
             }
@@ -68,4 +68,5 @@ fun launchGoogleSignIn(
     Button(onClick = { launchGoogleSignIn() }) {
         Text(text = "Sign in with Google")
     }
-}
+}
+
diff --git a/app/src/main/java/com/better/nothing/music/vizualizer/ui/fuckingInternetUpdates.kt b/app/src/main/java/com/better/nothing/music/vizualizer/ui/fuckingInternetUpdates.kt
@@ -1,8 +1,4 @@
 package com.better.nothing.music.vizualizer.ui
 
-import androidx.compose.material3.*
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.unit.dp
-import androidx.compose.foundation.shape.RoundedCornerShape
 
 

Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,6 @@ internal fun SettingsScreen(`
`89`	`89`	`onDismiss = { showAuthDialog = false },`
`90`	`90`	`onSignIn = { e, p -> viewModel.signInWithEmail(e, p) },`
`91`	`91`	`onSignUp = { e, p -> viewModel.signUpWithEmail(e, p) },`
`92`		`- onGoogleSignIn = onGoogleSignIn`
`93`	`92`	`)`
`94`	`93`	`}`
`95`	`94`