fix logcat not show in MIUI/HyperOS

Author: HatsuneMikuUwU

V2rayNG/app/src/main/java/com/v2ray/ang/ui/LogcatActivity.kt

@@ -68,7 +68,7 @@ class LogcatActivity : BaseActivity(), SwipeRefreshLayout.OnRefreshListener {
                 shareDir.listFiles()?.forEach { it.delete() }
 
                 val timestamp = SimpleDateFormat("yyyy-MM-dd_HH-mm-ss", Locale.US).format(Date())
-                val logFile = File(shareDir, "v2rayNG_logcat_$timestamp.txt")
+                val logFile = File(shareDir, "MikuRay_logcat_$timestamp.txt")
                 logFile.writeText(logText, Charsets.UTF_8)
 
                 val uri = FileProvider.getUriForFile(

V2rayNG/app/src/main/java/com/v2ray/ang/util/InProcessLogBuffer.kt

@@ -0,0 +1,38 @@
+package com.v2ray.ang.util
+
+import android.util.Log
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.LinkedList
+import java.util.Locale
+
+/**
+ * In-process log buffer — fallback when logcat is blocked (e.g. MIUI/HyperOS).
+ * Intercepts LogUtil calls and stores them in a bounded circular buffer.
+ */
+object InProcessLogBuffer {
+    private const val MAX_ENTRIES = 2000
+    private val buffer: LinkedList<String> = LinkedList()
+    private val fmt = SimpleDateFormat("MM-dd HH:mm:ss.SSS", Locale.US)
+
+    @Synchronized
+    fun append(priority: Int, tag: String, message: String) {
+        val level = when (priority) {
+            Log.VERBOSE -> "V"
+            Log.DEBUG -> "D"
+            Log.INFO -> "I"
+            Log.WARN -> "W"
+            Log.ERROR -> "E"
+            else -> "?"
+        }
+        val line = "${fmt.format(Date())} $level/$tag: $message"
+        if (buffer.size >= MAX_ENTRIES) buffer.removeFirst()
+        buffer.addLast(line)
+    }
+
+    @Synchronized
+    fun getAll(): List<String> = buffer.toList().reversed()
+
+    @Synchronized
+    fun clear() = buffer.clear()
+}

V2rayNG/app/src/main/java/com/v2ray/ang/util/LogUtil.kt

@@ -55,6 +55,8 @@ object LogUtil {
     private fun log(priority: Int, tag: String, message: String, throwable: Throwable? = null) {
         if (!isEnabled(priority)) return
 
+        val fullMessage = if (throwable != null) "$message\n${throwable.stackTraceToString()}" else message
+
         when {
             throwable == null -> Log.println(priority, tag, message)
             priority >= Log.ERROR -> Log.e(tag, message, throwable)
@@ -63,6 +65,10 @@ object LogUtil {
             priority == Log.DEBUG -> Log.d(tag, message, throwable)
             else -> Log.v(tag, message, throwable)
         }
+
+        // Feed into in-process buffer as fallback for devices (e.g. MIUI/HyperOS)
+        // where logcat exec is blocked for third-party apps.
+        InProcessLogBuffer.append(priority, tag, fullMessage)
     }
 
     fun d(tag: String = AppConfig.TAG, message: String) = log(Log.DEBUG, tag, message)

V2rayNG/app/src/main/java/com/v2ray/ang/viewmodel/LogcatViewModel.kt

@@ -1,51 +1,121 @@
 package com.v2ray.ang.viewmodel
 
+import android.os.Process
 import androidx.lifecycle.ViewModel
 import com.v2ray.ang.AppConfig
 import com.v2ray.ang.AppConfig.ANG_PACKAGE
+import com.v2ray.ang.util.InProcessLogBuffer
 import com.v2ray.ang.util.LogUtil
 import java.io.IOException
+import java.util.concurrent.TimeUnit
 
 class LogcatViewModel : ViewModel() {
     private val logsetsAll: MutableList<String> = mutableListOf()
     private var filteredLogs: List<String> = emptyList()
     private var currentFilter: String = ""
 
+    /** True if last load succeeded via logcat process; false = fell back to in-process buffer. */
+    var usedFallback: Boolean = false
+        private set
+
     fun getAll(): List<String> = filteredLogs
 
     fun loadLogcat() {
-        try {
-            val lst = LinkedHashSet<String>()
-            lst.add("logcat")
-            lst.add("-d")
-            lst.add("-v")
-            lst.add("time")
-            lst.add("-s")
-            lst.add("GoLog,${ANG_PACKAGE},AndroidRuntime,System.err")
-            val process = Runtime.getRuntime().exec(lst.toTypedArray())
-            val allText = process.inputStream.bufferedReader().use { it.readLines() }.reversed()
-
-            logsetsAll.clear()
-            logsetsAll.addAll(allText)
-            applyFilter()
+        val lines = tryLogcatProcessBuilder()
+            ?: tryLogcatPidOnly()
+            ?: useInProcessBuffer()
+
+        logsetsAll.clear()
+        logsetsAll.addAll(lines)
+        applyFilter()
+    }
+
+    /**
+     * Strategy 1: ProcessBuilder with stderr merged.
+     * More reliable than Runtime.exec on MIUI — avoids shell escaping issues
+     * and correctly captures GoLog output on stderr.
+     */
+    private fun tryLogcatProcessBuilder(): List<String>? {
+        return try {
+            val process = ProcessBuilder(
+                "logcat", "-d", "-v", "time",
+                "-s", "GoLog,$ANG_PACKAGE,AndroidRuntime,System.err"
+            )
+                .redirectErrorStream(true)
+                .start()
+
+            val exited = process.waitFor(5, TimeUnit.SECONDS)
+            if (!exited) {
+                process.destroyForcibly()
+                return null
+            }
+
+            val lines = process.inputStream.bufferedReader().readLines()
+            if (lines.isEmpty()) null
+            else {
+                usedFallback = false
+                lines.reversed()
+            }
         } catch (e: IOException) {
-            LogUtil.e(AppConfig.TAG, "Failed to get logcat", e)
+            LogUtil.w(AppConfig.TAG, "logcat ProcessBuilder failed: ${e.message}")
+            null
+        } catch (e: SecurityException) {
+            LogUtil.w(AppConfig.TAG, "logcat ProcessBuilder blocked: ${e.message}")
+            null
         }
     }
 
+    /**
+     * Strategy 2: Filter by own PID only.
+     * MIUI/HyperOS sometimes allows reading own-process logs even when
+     * broad logcat access is restricted.
+     */
+    private fun tryLogcatPidOnly(): List<String>? {
+        return try {
+            val pid = Process.myPid().toString()
+            val process = ProcessBuilder("logcat", "-d", "-v", "time", "--pid=$pid")
+                .redirectErrorStream(true)
+                .start()
+
+            val exited = process.waitFor(5, TimeUnit.SECONDS)
+            if (!exited) {
+                process.destroyForcibly()
+                return null
+            }
+
+            val lines = process.inputStream.bufferedReader().readLines()
+            if (lines.isEmpty()) null
+            else {
+                usedFallback = false
+                lines.reversed()
+            }
+        } catch (e: Exception) {
+            LogUtil.w(AppConfig.TAG, "logcat --pid fallback failed: ${e.message}")
+            null
+        }
+    }
+
+    /**
+     * Strategy 3: In-process buffer captured by LogUtil.
+     * Always works regardless of OS restrictions.
+     */
+    private fun useInProcessBuffer(): List<String> {
+        usedFallback = true
+        return InProcessLogBuffer.getAll()
+    }
+
     fun clearLogcat() {
         try {
-            val lst = LinkedHashSet<String>()
-            lst.add("logcat")
-            lst.add("-c")
-            val process = Runtime.getRuntime().exec(lst.toTypedArray())
-            process.waitFor()
-
-            logsetsAll.clear()
-            filteredLogs = emptyList()
-        } catch (e: IOException) {
-            LogUtil.e(AppConfig.TAG, "Failed to clear logcat", e)
+            val process = ProcessBuilder("logcat", "-c")
+                .redirectErrorStream(true)
+                .start()
+            process.waitFor(3, TimeUnit.SECONDS)
+        } catch (e: Exception) {
+            LogUtil.w(AppConfig.TAG, "logcat clear failed: ${e.message}")
         }
+        InProcessLogBuffer.clear()
+        logsetsAll.clear()
+        filteredLogs = emptyList()
     }
 
     fun filter(content: String?) {
@@ -57,7 +127,7 @@ class LogcatViewModel : ViewModel() {
         filteredLogs = if (currentFilter.isEmpty()) {
             logsetsAll.toList()
         } else {
-            logsetsAll.filter { it.contains(currentFilter) }
+            logsetsAll.filter { it.contains(currentFilter, ignoreCase = true) }
         }
     }
 }