1.4.1: the place follows the person

The app keeps the position fresh while it is on screen (a fix every minute
or after a few dozen meters) and pushes every fix into the chat, so the
place moves with the person instead of being a one-time setting. The
address is street-level now: the house number is left out on purpose.

Co-Authored-By: opencode <opencode@openai.com>

README.md

@@ -11,6 +11,15 @@ resources.
   picker), images, generated files, settings, themes.
 - **Share anything to NikoGPT**: from another app share text or any file
   (photos, PDFs, audio, archives…) straight into the composer.
+- **Personal context**: the app can tell the chat where you are (the street
+  you are on — never the house number; Android geocodes the position itself)
+  and which phone you write from (model and firmware). The place follows you:
+  the app keeps the position fresh while it is on screen. Both are optional
+  and switched on in **Settings → Context**.
+- **Updates itself**: the app checks the published version on launch and
+  offers the update right there (download + system installer). The check can
+  be turned off in **Settings → App**, or with "don't check again" in the
+  dialog.
 - Downloads go through Android's `DownloadManager` (with your session
   cookies), links to other sites open in the system browser.
 - **Open in the browser only**: `chat.n1ko.dev` loads inside; anything else
@@ -27,7 +36,7 @@ Download the APK from the releases page:
 **https://git.n1ko.dev/Niko/nikogpt_android/releases**
 
 Latest build:
-https://git.n1ko.dev/Niko/nikogpt_android/releases/download/v1.3.0/nikogpt-android-1.3.0.apk
+https://git.n1ko.dev/Niko/nikogpt_android/releases/download/v1.4.1/nikogpt-android-1.4.1.apk
 
 Open the APK on the phone (allow installing apps from this source when Android
 asks). The APKs are signed with the project's release key; Android may still

app/build.gradle.kts

@@ -22,8 +22,8 @@ android {
         applicationId = "dev.n1ko.nikogpt"
         minSdk = 29 // Android 10
         targetSdk = 35
-        versionCode = 11
+        versionCode = 14
-        versionName = "1.3.0"
+        versionName = "1.4.1"
     }
 
     signingConfigs {

app/src/main/AndroidManifest.xml

@@ -2,8 +2,14 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <uses-permission android:name="android.permission.INTERNET" />
+    <!-- In-app updates: install the downloaded APK (the user confirms in the system dialog). -->
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
     <!-- Voice input in the web chat (MediaRecorder + server-side recognition). -->
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <!-- Personal context: the place the person is (only when they ask for it
+         in the chat settings). -->
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
 
     <application
         android:allowBackup="false"

app/src/main/java/dev/n1ko/nikogpt/MainActivity.kt

@@ -8,10 +8,17 @@ import android.content.ActivityNotFoundException
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
+import android.location.Geocoder
+import android.location.Location
+import android.location.LocationListener
+import android.location.LocationManager
 import android.net.Uri
 import android.net.http.SslError
+import android.os.Looper
+import android.provider.Settings
 import android.provider.OpenableColumns
 import android.util.Base64
+import android.os.Build
 import android.os.Bundle
 import android.os.Environment
 import android.view.View
@@ -28,6 +35,8 @@ import android.webkit.WebResourceRequest
 import android.webkit.WebSettings
 import android.webkit.WebView
 import android.webkit.WebViewClient
+import java.net.HttpURLConnection
+import java.net.URL
 import android.widget.Button
 import android.widget.LinearLayout
 import android.widget.ProgressBar
@@ -56,7 +65,9 @@ import com.google.android.gms.common.api.ApiException
 import com.google.android.libraries.identity.googleid.GetGoogleIdOption
 import com.google.android.libraries.identity.googleid.GoogleIdTokenCredential
 import java.io.File
+import java.util.Locale
 import kotlinx.coroutines.launch
+import org.json.JSONObject
 
 /**
  * The whole app: a thin, open-source WebView around the NikoGPT web chat.
@@ -156,6 +167,30 @@ class MainActivity : AppCompatActivity() {
             if (ok && uri != null) cb?.onReceiveValue(arrayOf(uri)) else cb?.onReceiveValue(null)
         }
 
+    // Runtime location permission, bridged to the WebView: the page asks
+    // where the person is, the system asks whether it may know.
+    private var pendingLocation = false
+    // Whether the person shared the place: the page keeps the tracking in
+    // step with that switch.
+    private var tracking = false
+    // Whether the position updates are registered with the system.
+    private var locationUpdatesOn = false
+    // The last point the street was resolved for: the address only changes
+    // when the person moves.
+    private var lastGeocoded: Location? = null
+    private var lastAddress: String? = null
+    private var lastGeocodedAt = 0L
+    private val locationPermission: ActivityResultLauncher<String> =
+        registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
+            if (!pendingLocation) return@registerForActivityResult
+            pendingLocation = false
+            if (!granted) {
+                deliverLocationError()
+                return@registerForActivityResult
+            }
+            if (tracking) startTracking() else requestFix()
+        }
+
     @SuppressLint("SetJavaScriptEnabled")
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -243,6 +278,7 @@ class MainActivity : AppCompatActivity() {
                 // Persist cookies (the session) right after the page settles.
                 CookieManager.getInstance().flush()
                 maybeDeliverShare()
+                checkForUpdates()
             }
         }
 
@@ -348,6 +384,11 @@ class MainActivity : AppCompatActivity() {
     // One file shared into the app, waiting for the page to be ready.
     private data class SharedFile(val uri: Uri, val name: String, val mime: String, val size: Long)
 
+    // Update checks: on by default, switchable from the web settings (the
+    // bridge below) or the update dialog ("don't check again").
+    private val prefs by lazy { getSharedPreferences("nikogpt", Context.MODE_PRIVATE) }
+    private var updateChecked = false
+
     // handleShareIntent catches "Share to NikoGPT" from other apps: text goes
     // into the composer, files of any type into the attachments.
     private fun handleShareIntent(intent: Intent?) {
@@ -484,6 +525,249 @@ class MainActivity : AppCompatActivity() {
         fun setAtTop(atTop: Boolean) {
             webAtTop = atTop
         }
+
+        // The settings screen shows an "updates" switch; the preference lives
+        // here because it is per device, not per account.
+        @JavascriptInterface
+        fun updateChecksEnabled(): Boolean = prefs.getBoolean("update_checks", true)
+
+        @JavascriptInterface
+        fun setUpdateChecks(enabled: Boolean) {
+            prefs.edit().putBoolean("update_checks", enabled).apply()
+            if (enabled) {
+                // Switched on: check right away instead of on the next launch.
+                runOnUiThread {
+                    updateChecked = false
+                    checkForUpdates()
+                }
+            }
+        }
+
+        // deviceInfo describes the phone for the personal context: the model
+        // and the firmware build the app runs on.
+        @JavascriptInterface
+        fun deviceInfo(): String = deviceInfoJSON().toString()
+
+        // requestLocation asks Android for a position and geocodes it with the
+        // system service, so the chat gets a street-level address. The result
+        // goes back into the page through nikoDeviceLocation.
+        @JavascriptInterface
+        fun requestLocation() {
+            runOnUiThread { startLocation() }
+        }
+
+        // startLocationUpdates begins tracking the person: every fix is
+        // pushed into the page, so the place follows them. The page starts
+        // it only while the location is shared.
+        @JavascriptInterface
+        fun startLocationUpdates() {
+            runOnUiThread {
+                tracking = true
+                if (hasLocationPermission()) startTracking() else {
+                    pendingLocation = true
+                    locationPermission.launch(Manifest.permission.ACCESS_FINE_LOCATION)
+                }
+            }
+        }
+
+        // stopLocationUpdates ends the tracking.
+        @JavascriptInterface
+        fun stopLocationUpdates() {
+            runOnUiThread {
+                tracking = false
+                stopTracking()
+            }
+        }
+    }
+
+    // hasLocationPermission reports whether the app may read the position.
+    private fun hasLocationPermission(): Boolean {
+        return ContextCompat.checkSelfPermission(
+            this, Manifest.permission.ACCESS_FINE_LOCATION,
+        ) == PackageManager.PERMISSION_GRANTED ||
+            ContextCompat.checkSelfPermission(
+                this, Manifest.permission.ACCESS_COARSE_LOCATION,
+            ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    // deviceInfoJSON is the phone description the personal context carries.
+    private fun deviceInfoJSON(): JSONObject {
+        val model = deviceModel()
+        val firmware = deviceFirmware()
+        return JSONObject()
+            .put("model", model)
+            .put("firmware", firmware)
+            .put("os", Build.VERSION.RELEASE)
+            .put("app", BuildConfig.VERSION_NAME)
+    }
+
+    // deviceModel is the marketing name of the phone ("Google Pixel 8").
+    private fun deviceModel(): String {
+        val manufacturer = Build.MANUFACTURER?.trim().orEmpty()
+        val model = Build.MODEL?.trim().orEmpty()
+        if (manufacturer.isEmpty()) return model
+        if (model.startsWith(manufacturer, ignoreCase = true)) return model
+        return "$manufacturer $model"
+    }
+
+    // deviceFirmware is the firmware build ("Android 15 (AP3A.241105.007)").
+    private fun deviceFirmware(): String {
+        val release = Build.VERSION.RELEASE?.trim().orEmpty()
+        val build = Build.DISPLAY?.trim().orEmpty()
+        return if (build.isEmpty()) "Android $release" else "Android $release ($build)"
+    }
+
+    // startLocation runs the permission dance and then asks for a fix. The
+    // answer (or the error) goes back into the page.
+    private fun startLocation() {
+        if (hasLocationPermission()) {
+            requestFix()
+            return
+        }
+        pendingLocation = true
+        locationPermission.launch(Manifest.permission.ACCESS_FINE_LOCATION)
+    }
+
+    // startTracking registers the ongoing position updates: a fix every
+    // minute, or as soon as the person has walked a few dozen meters.
+    private fun startTracking() {
+        if (locationUpdatesOn) return
+        val lm = getSystemService(Context.LOCATION_SERVICE) as LocationManager
+        val provider = when {
+            lm.isProviderEnabled(LocationManager.GPS_PROVIDER) -> LocationManager.GPS_PROVIDER
+            lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER) -> LocationManager.NETWORK_PROVIDER
+            else -> null
+        } ?: return
+        try {
+            lm.requestLocationUpdates(provider, 60_000L, 50f, locationListener, Looper.getMainLooper())
+            locationUpdatesOn = true
+        } catch (_: Exception) {
+        }
+    }
+
+    // stopTracking unregisters the position updates.
+    private fun stopTracking() {
+        if (!locationUpdatesOn) return
+        locationUpdatesOn = false
+        try {
+            val lm = getSystemService(Context.LOCATION_SERVICE) as LocationManager
+            lm.removeUpdates(locationListener)
+        } catch (_: Exception) {
+        }
+    }
+
+    // locationListener receives the ongoing fixes.
+    private val locationListener = LocationListener { location -> deliverLocation(location) }
+
+    // requestFix takes a position from the system location manager. GPS is
+    // preferred (it is precise enough for a street); the network provider is
+    // the fallback, and the last known position answers when both are slow.
+    private fun requestFix() {
+        val lm = getSystemService(Context.LOCATION_SERVICE) as LocationManager
+        val provider = when {
+            lm.isProviderEnabled(LocationManager.GPS_PROVIDER) -> LocationManager.GPS_PROVIDER
+            lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER) -> LocationManager.NETWORK_PROVIDER
+            else -> null
+        }
+        if (provider == null) {
+            deliverLocationError()
+            return
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            lm.getCurrentLocation(provider, null, mainExecutor) { location ->
+                if (location != null) {
+                    deliverLocation(location)
+                } else {
+                    val last = lastKnownLocation(lm)
+                    if (last != null) deliverLocation(last) else deliverLocationError()
+                }
+            }
+        } else {
+            @Suppress("DEPRECATION")
+            lm.requestSingleUpdate(
+                provider,
+                { location -> deliverLocation(location) },
+                Looper.getMainLooper(),
+            )
+        }
+    }
+
+    // lastKnownLocation is the freshest position the system still remembers.
+    private fun lastKnownLocation(lm: LocationManager): Location? {
+        var best: Location? = null
+        for (provider in listOf(LocationManager.GPS_PROVIDER, LocationManager.NETWORK_PROVIDER)) {
+            val loc = try { lm.getLastKnownLocation(provider) } catch (_: Exception) { null }
+            if (loc == null) continue
+            if (System.currentTimeMillis() - loc.time > 30 * 60 * 1000) continue
+            if (best == null || loc.time > best.time) best = loc
+        }
+        return best
+    }
+
+    // deliverLocation geocodes the position in the background and hands the
+    // address, the coordinates and the phone details to the page.
+    private fun deliverLocation(location: Location) {
+        Thread {
+            val address = streetAddress(location)
+            val payload = deviceInfoJSON()
+                .put("lat", location.latitude)
+                .put("lon", location.longitude)
+                .put("accuracy", location.accuracy.toDouble())
+            if (address != null) payload.put("address", address)
+            runOnUiThread { sendLocation(payload) }
+        }.start()
+    }
+
+    // streetAddress resolves the street the person is on. The address is
+    // resolved only when they have actually moved: the street is what the
+    // chat gets, the house number is left out on purpose.
+    private fun streetAddress(location: Location): String? {
+        val prev = lastGeocoded
+        if (prev != null && lastAddress != null &&
+            prev.distanceTo(location) < 100f &&
+            System.currentTimeMillis() - lastGeocodedAt < 10 * 60 * 1000
+        ) {
+            return lastAddress
+        }
+        val address = geocode(location)
+        if (address != null) {
+            lastGeocoded = Location(location)
+            lastAddress = address
+            lastGeocodedAt = System.currentTimeMillis()
+        }
+        return address
+    }
+
+    // geocode turns a position into a street address with the system
+    // service. It returns null when the device has no geocoder backend.
+    private fun geocode(location: Location): String? {
+        return try {
+            @Suppress("DEPRECATION")
+            val addresses = Geocoder(this, Locale.getDefault()).getFromLocation(
+                location.latitude, location.longitude, 1,
+            )
+            val a = addresses?.firstOrNull() ?: return null
+            listOfNotNull(a.thoroughfare, a.locality ?: a.subAdminArea, a.countryName)
+                .filter { it.isNotBlank() }
+                .joinToString(", ")
+                .ifBlank { null }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    // deliverLocationError tells the page that no position could be found.
+    private fun deliverLocationError() {
+        runOnUiThread {
+            sendLocation(JSONObject().put("error", "location unavailable"))
+        }
+    }
+
+    // sendLocation calls back into the page with the location payload.
+    private fun sendLocation(payload: JSONObject) {
+        val js = "window.nikoDeviceLocation && window.nikoDeviceLocation(" +
+            org.json.JSONObject.quote(payload.toString()) + ")"
+        webView.evaluateJavascript(js, null)
     }
 
     // openGooglePicker tries the native pickers in order: Credential Manager
@@ -574,6 +858,132 @@ class MainActivity : AppCompatActivity() {
         handleShareIntent(intent)
     }
 
+    // checkForUpdates asks the bot for the published app version once per
+    // launch (and only when the check is enabled) and offers the download.
+    // It uses the WebView's session cookie, so it runs after the page settled.
+    private fun checkForUpdates() {
+        if (updateChecked) return
+        if (!prefs.getBoolean("update_checks", true)) return
+        if (webView.url == null) return
+        val cookie = CookieManager.getInstance().getCookie(START_URL)
+        if (cookie.isNullOrBlank()) return
+        updateChecked = true
+        Thread {
+            val info = fetchAppInfo(cookie) ?: return@Thread
+            val remote = info.optString("android_version").trim()
+            val apk = info.optString("apk_url").trim()
+            if (remote.isEmpty() || apk.isEmpty()) return@Thread
+            if (!versionNewer(remote, BuildConfig.VERSION_NAME)) return@Thread
+            runOnUiThread { showUpdateDialog(remote, apk) }
+        }.start()
+    }
+
+    // fetchAppInfo reads /api/app with the signed-in session.
+    private fun fetchAppInfo(cookie: String): org.json.JSONObject? {
+        return try {
+            val conn = (URL("https://$HOST/api/app").openConnection() as HttpURLConnection).apply {
+                requestMethod = "GET"
+                setRequestProperty("Cookie", cookie)
+                connectTimeout = 15000
+                readTimeout = 15000
+            }
+            val body = conn.inputStream.bufferedReader().use { it.readText() }
+            conn.disconnect()
+            org.json.JSONObject(body)
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    // versionNewer reports whether "remote" is a higher dotted version.
+    private fun versionNewer(remote: String, local: String): Boolean {
+        fun parts(v: String) = v.split('.').map { it.takeWhile(Char::isDigit).toIntOrNull() ?: 0 }
+        val a = parts(remote)
+        val b = parts(local)
+        for (i in 0 until maxOf(a.size, b.size)) {
+            val x = a.getOrElse(i) { 0 }
+            val y = b.getOrElse(i) { 0 }
+            if (x != y) return x > y
+        }
+        return false
+    }
+
+    private fun showUpdateDialog(version: String, apkUrl: String) {
+        if (isFinishing || isDestroyed) return
+        AlertDialog.Builder(this)
+            .setTitle(R.string.update_title)
+            .setMessage(getString(R.string.update_message, version, BuildConfig.VERSION_NAME))
+            .setPositiveButton(R.string.update_now) { _, _ -> startUpdateDownload(apkUrl) }
+            .setNegativeButton(R.string.update_later, null)
+            .setNeutralButton(R.string.update_never) { _, _ ->
+                prefs.edit().putBoolean("update_checks", false).apply()
+            }
+            .show()
+    }
+
+    // startUpdateDownload fetches the APK into the cache and hands it to the
+    // system installer. Without the "install unknown apps" grant it walks the
+    // user through the settings once; on any failure the browser opens the
+    // APK link instead.
+    private fun startUpdateDownload(apkUrl: String) {
+        if (!packageManager.canRequestPackageInstalls()) {
+            Toast.makeText(this, R.string.update_install_hint, Toast.LENGTH_LONG).show()
+            try {
+                startActivity(
+                    Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES)
+                        .setData(Uri.parse("package:$packageName"))
+                )
+            } catch (_: Exception) {
+            }
+            return
+        }
+        val progress = AlertDialog.Builder(this)
+            .setTitle(R.string.update_downloading)
+            .setCancelable(false)
+            .create()
+        progress.show()
+        Thread {
+            val target = java.io.File(cacheDir, "updates").apply { mkdirs() }
+            val apkFile = java.io.File(target, "nikogpt-update.apk")
+            var ok = false
+            try {
+                val conn = (URL(apkUrl).openConnection() as HttpURLConnection).apply {
+                    requestMethod = "GET"
+                    connectTimeout = 20000
+                    readTimeout = 60000
+                }
+                conn.inputStream.use { input ->
+                    apkFile.outputStream().use { output -> input.copyTo(output) }
+                }
+                conn.disconnect()
+                ok = apkFile.length() > 0
+            } catch (_: Exception) {
+                ok = false
+            }
+            runOnUiThread {
+                progress.dismiss()
+                if (ok) installApk(apkFile, apkUrl) else {
+                    Toast.makeText(this, R.string.update_failed, Toast.LENGTH_LONG).show()
+                    openExternally(Uri.parse(apkUrl))
+                }
+            }
+        }.start()
+    }
+
+    private fun installApk(file: java.io.File, apkUrl: String) {
+        try {
+            val uri = FileProvider.getUriForFile(this, "dev.n1ko.nikogpt.files", file)
+            startActivity(
+                Intent(Intent.ACTION_VIEW)
+                    .setDataAndType(uri, "application/vnd.android.package-archive")
+                    .addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_ACTIVITY_NEW_TASK)
+            )
+        } catch (e: Exception) {
+            Toast.makeText(this, R.string.update_failed, Toast.LENGTH_LONG).show()
+            openExternally(Uri.parse(apkUrl))
+        }
+    }
+
     private fun openExternally(uri: Uri) {
         try {
             startActivity(Intent(Intent.ACTION_VIEW, uri).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
@@ -607,6 +1017,14 @@ class MainActivity : AppCompatActivity() {
         // session cookie can be lost when Android kills the process, so the
         // user would have to log in again after every restart.
         CookieManager.getInstance().flush()
+        // The position is only tracked while the app is on screen.
+        stopTracking()
+    }
+
+    override fun onStart() {
+        super.onStart()
+        // Back on screen: the tracking continues where it stopped.
+        if (tracking && hasLocationPermission()) startTracking()
     }
 
     override fun onSaveInstanceState(outState: Bundle) {

app/src/main/res/values-ru/strings.xml

@@ -11,5 +11,13 @@
     <string name="google_no_token">Google не вернул ID-токен (проверьте Android OAuth-клиент: package и SHA-1)</string>
     <string name="attach_file">Файл</string>
     <string name="share_too_big">Слишком большой файл: %1$s (в чат помещается до 16 МБ)</string>
+    <string name="update_title">Доступно обновление</string>
+    <string name="update_message">Вышла версия NikoGPT %1$s. У вас %2$s.</string>
+    <string name="update_now">Обновить</string>
+    <string name="update_later">Позже</string>
+    <string name="update_never">Больше не проверять</string>
+    <string name="update_downloading">Скачиваю обновление…</string>
+    <string name="update_failed">Не удалось скачать обновление — открываю его в браузере</string>
+    <string name="update_install_hint">Разрешите этому приложению устанавливать обновления в открывшихся настройках и нажмите «Обновить» ещё раз.</string>
     <string name="attach_camera">Камера</string>
 </resources>

app/src/main/res/values/strings.xml

@@ -11,5 +11,13 @@
     <string name="google_no_token">Google did not return an ID token (check the Android OAuth client, package and SHA-1)</string>
     <string name="attach_file">File</string>
     <string name="share_too_big">Too big to send: %1$s (the chat accepts up to 16 MB)</string>
+    <string name="update_title">Ready to update</string>
+    <string name="update_message">NikoGPT %1$s is available. You have %2$s.</string>
+    <string name="update_now">Update</string>
+    <string name="update_later">Later</string>
+    <string name="update_never">Don\'t check again</string>
+    <string name="update_downloading">Downloading the update…</string>
+    <string name="update_failed">Could not download the update — opening it in the browser instead</string>
+    <string name="update_install_hint">Allow this app to install updates in the settings that just opened, then tap Update again.</string>
     <string name="attach_camera">Camera</string>
 </resources>

app/src/main/res/xml/file_paths.xml

@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <paths>
     <cache-path name="camera" path="camera/" />
+    <cache-path name="updates" path="updates/" />
 </paths>