diff --git a/android/app/build.gradle b/android/app/build.gradle
index a725c471..d2f10b2d 100755
--- a/android/app/build.gradle
+++ b/android/app/build.gradle
@@ -23,8 +23,8 @@ android {
         applicationId "com.openipc.decoder"
         minSdk 21
         targetSdk 36
-        versionCode 35
-        versionName "2.10"
+        versionCode 36
+        versionName "2.11"
 
         buildConfigField "String", "GIT_HASH", "\"${getGitHash()}\""
     }
diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml
index 922a4fe1..bb26eb26 100755
--- a/android/app/src/main/AndroidManifest.xml
+++ b/android/app/src/main/AndroidManifest.xml
@@ -14,6 +14,14 @@
     <!-- The multicast permission must not hide the app on Ethernet-only boxes (#68) -->
     <uses-feature android:name="android.hardware.wifi" android:required="false" />
 
+    <!-- Save report (#207): is there an app to share it with? Android 11+ shows only these -->
+    <queries>
+        <intent>
+            <action android:name="android.intent.action.SEND" />
+            <data android:mimeType="text/plain" />
+        </intent>
+    </queries>
+
     <!-- For Android 10+ -->
     <application
         android:name=".App"
diff --git a/android/app/src/main/java/com/openipc/decoder/DebugServer.java b/android/app/src/main/java/com/openipc/decoder/DebugServer.java
index 453e2e62..ab8c9a0b 100644
--- a/android/app/src/main/java/com/openipc/decoder/DebugServer.java
+++ b/android/app/src/main/java/com/openipc/decoder/DebugServer.java
@@ -17,6 +17,8 @@
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.nio.charset.StandardCharsets;
+import java.text.SimpleDateFormat;
+import java.util.Date;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -30,7 +32,7 @@
 /**
  * Serves what the decoder knows about itself on port 8085, for a browser or curl:
  * {@code /} a page refreshing itself, {@code /stats.json} the same as JSON, {@code /log} the
- * app's recent log. Always on; a client outside the local network gets 403. GET only, one
+ * app's recent log, {@code /report.txt} both in one file to download (#207). Always on; a client outside the local network gets 403. GET only, one
  * request per connection, short timeouts and a few workers: it must never get in the way of
  * decoding. Logins and passwords never leave the device (redacted like the log, #55).
  */
@@ -93,7 +95,8 @@ interface Source {
     /** Bumped when the source changes: a picture of an earlier source is never served. */
     private volatile int sourceGen;
 
-    private DebugServer() {}
+    /** Package-private for the tests: no threads, nothing bound. */
+    DebugServer() {}
 
     /** The one server of the process, started on first use and kept for its lifetime. */
     static synchronized DebugServer get() {
@@ -179,25 +182,7 @@ private void handle(Socket s) {
                 query = path.substring(q + 1);
                 path = path.substring(0, q);
             }
-            switch (path) {
-                case "/":
-                case "/index.html":
-                    reply(out, 200, "text/html; charset=utf-8", PAGE);
-                    break;
-                case "/stats.json":
-                    reply(out, 200, "application/json; charset=utf-8", toJson(snapshot(), true));
-                    break;
-                case "/snapshot.jpg":
-                    byte[] jpeg = snapshotJpeg(!("&" + query + "&").contains("&labels=0&"));
-                    if (jpeg != null) reply(out, 200, "image/jpeg", jpeg);
-                    else reply(out, 503, "text/plain", "No picture\n");
-                    break;
-                case "/log":
-                    reply(out, 200, "text/plain; charset=utf-8", log.text());
-                    break;
-                default:
-                    reply(out, 404, "text/plain", "Not found\n");
-            }
+            serve(out, path, query);
         } catch (IOException e) {
             // The client went away or was too slow: nothing to report
         } catch (RuntimeException e) {
@@ -207,6 +192,91 @@ private void handle(Socket s) {
         }
     }
 
+    /** Answers one GET of a LAN client (checked by the caller). */
+    void serve(OutputStream out, String path, String query) throws IOException {
+        switch (path) {
+            case "/":
+            case "/index.html":
+                reply(out, 200, "text/html; charset=utf-8", PAGE);
+                break;
+            case "/stats.json":
+                reply(out, 200, "application/json; charset=utf-8", toJson(snapshot(), true));
+                break;
+            case "/snapshot.jpg":
+                byte[] jpeg = snapshotJpeg(!("&" + query + "&").contains("&labels=0&"));
+                if (jpeg != null) reply(out, 200, "image/jpeg", jpeg);
+                else reply(out, 503, "text/plain", "No picture\n");
+                break;
+            case "/log":
+                reply(out, 200, "text/plain; charset=utf-8", log.text());
+                break;
+            case "/report.txt":
+                // Downloaded by the browser, not shown (#207)
+                Date now = new Date();
+                reply(out, 200, "text/plain; charset=utf-8",
+                        reportText(now).getBytes(StandardCharsets.UTF_8),
+                        "Content-Disposition: attachment; filename=\"" + reportName(now)
+                                + "\"\r\n");
+                break;
+            default:
+                reply(out, 404, "text/plain", "Not found\n");
+        }
+    }
+
+    // ====================== Report (#207) ======================
+
+    /**
+     * The report as the app saves it and /report.txt serves it: the same text both ways. Slow
+     * (the state is read on the UI thread, up to a timeout): not on the UI thread.
+     */
+    String reportText(Date now) {
+        return reportText(snapshot(), log.text(), now,
+                android.os.SystemClock.elapsedRealtime() / 1000);
+    }
+
+    /** The report's first line. */
+    static final String REPORT_TITLE = "OpenIPC Decoder report";
+
+    /** report-YYYYMMDD-HHMMSS.txt, local time. */
+    static String reportName(Date now) {
+        return "report-" + new SimpleDateFormat("yyyyMMdd-HHmmss", Locale.US).format(now) + ".txt";
+    }
+
+    /**
+     * A header (app, version, git hash, device, Android, time, uptime), then the state as
+     * /stats.json has it, then the log ring. Both are redacted already; the whole text is
+     * redacted once more, so nothing that slipped in on the way leaves the device.
+     */
+    static String reportText(Map<String, Object> stats, String log, Date now, long uptimeS) {
+        StringBuilder sb = new StringBuilder(64 * 1024);
+        sb.append(REPORT_TITLE).append('\n');
+        sb.append("App: OpenIPC Decoder ").append(BuildConfig.VERSION_NAME)
+                .append(" (").append(BuildConfig.VERSION_CODE).append("), git ")
+                .append(BuildConfig.GIT_HASH).append('\n');
+        sb.append("Device: ").append(android.os.Build.MANUFACTURER).append(' ')
+                .append(android.os.Build.MODEL).append('\n');
+        sb.append("Android: ").append(android.os.Build.VERSION.RELEASE).append(" (SDK ")
+                .append(android.os.Build.VERSION.SDK_INT).append(")\n");
+        sb.append("Time: ").append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z", Locale.US)
+                .format(now)).append('\n');
+        sb.append("Uptime: ").append(uptime(uptimeS)).append('\n');
+        sb.append("\n== stats.json ==\n");
+        sb.append(toJson(stats, true));
+        sb.append("\n== log ==\n");
+        sb.append(log != null ? log : "");
+        return redact(sb.toString());
+    }
+
+    /** 1d 2h 3m 4s; the leading zero units left out. */
+    static String uptime(long s) {
+        long d = s / 86400, h = s % 86400 / 3600, m = s % 3600 / 60;
+        StringBuilder sb = new StringBuilder();
+        if (d > 0) sb.append(d).append("d ");
+        if (d > 0 || h > 0) sb.append(h).append("h ");
+        if (d > 0 || h > 0 || m > 0) sb.append(m).append("m ");
+        return sb.append(s % 60).append('s').toString();
+    }
+
     private Map<String, Object> snapshot() {
         Source s = source;
         Map<String, Object> m;
@@ -270,11 +340,18 @@ private static void reply(OutputStream out, int code, String type, String body)
 
     private static void reply(OutputStream out, int code, String type, byte[] data)
             throws IOException {
+        reply(out, code, type, data, "");
+    }
+
+    /** {@code extra}: more header lines, each ending with \r\n. */
+    private static void reply(OutputStream out, int code, String type, byte[] data, String extra)
+            throws IOException {
         String head = "HTTP/1.1 " + code + " " + reason(code) + "\r\n"
                 + "Content-Type: " + type + "\r\n"
                 + "Content-Length: " + data.length + "\r\n"
                 + "Cache-Control: no-store\r\n"
                 + (code == 405 ? "Allow: GET\r\n" : "")
+                + extra
                 + "Connection: close\r\n\r\n";
         out.write(head.getBytes(StandardCharsets.ISO_8859_1));
         out.write(data);
@@ -466,7 +543,8 @@ private static void closeQuietly(Socket s) {
             + "<div class=\"meta\"><span id=\"ver\"></span><span id=\"clock\"></span><span"
             + " id=\"up\"></span><span id=\"err\"></span></div>"
             + "<nav><a class=\"btn\" href=\"/stats.json\">JSON</a><a class=\"btn\" href=\"/log\">"
-            + "Log</a>"
+            + "Log</a><a class=\"btn\" href=\"/report.txt\" download"
+            + " title=\"Header, stats.json and the log in one file\">Save report</a>"
             + "<span>Info<span class=\"seg\" id=\"info\"><button value=\"1\">On</button>"
             + "<button value=\"0\">Off</button></span></span>"
             + "<span>Snapshot<span class=\"seg\" id=\"every\"><button value=\"3\">3 s</button>"
diff --git a/android/app/src/main/java/com/openipc/decoder/Decoder.java b/android/app/src/main/java/com/openipc/decoder/Decoder.java
index 77a02026..6ae2c30e 100755
--- a/android/app/src/main/java/com/openipc/decoder/Decoder.java
+++ b/android/app/src/main/java/com/openipc/decoder/Decoder.java
@@ -10,6 +10,8 @@
 import android.annotation.SuppressLint;
 import android.app.Activity;
 
+import android.content.ActivityNotFoundException;
+import android.content.ClipData;
 import android.content.ContentValues;
 import android.content.Intent;
 import android.content.SharedPreferences;
@@ -45,8 +47,11 @@
 import android.widget.TextView;
 import android.widget.Toast;
 
+import java.io.File;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
 
 import java.text.SimpleDateFormat;
 import java.util.Arrays;
@@ -423,8 +428,9 @@ public void onToggleStats() {
             if (quadStats[i] == null || c == null) continue;
             quadStats[i].setVisibility(showStats ? View.VISIBLE : View.GONE);
         }
-        Toast.makeText(this, showStats ? "Debug text on" : "Debug text off",
-                Toast.LENGTH_SHORT).show();
+        // The report is on the same item (#207): said where it is seen
+        Toast.makeText(this, showStats ? "Debug text on \u00b7 hold Debug to save a report"
+                : "Debug text off", Toast.LENGTH_SHORT).show();
     }
 
     /** One line http://<address>:8085/ per device address while the debug text is on. */
@@ -614,6 +620,12 @@ private void loadSettings() {
 
         Intent intent = getIntent();
         String link = intent.getStringExtra(Intent.EXTRA_TEXT);
+        // A report shared back to the app (#207) is no camera link (Qodo on #208)
+        if (link != null && link.startsWith(DebugServer.REPORT_TITLE)) {
+            Log.i(TAG, "Shared text is a report, not a link: ignored");
+            intent.removeExtra(Intent.EXTRA_TEXT);
+            link = null;
+        }
         if (link != null) {
             Log.d(TAG, "Link: " + Uri.parse(link).getHost());
             mHosts[mActive] = sanitizeUrl(link);
@@ -1782,6 +1794,11 @@ && checkSelfPermission(android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
     @Override
     public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] results) {
         super.onRequestPermissionsResult(requestCode, permissions, results);
+        if (requestCode == REQUEST_STORAGE_FOR_REPORT) {
+            // Refused: saved all the same, in the app's own folder (#207)
+            startSavingReport();
+            return;
+        }
         if (requestCode != REQUEST_STORAGE_FOR_SCREENSHOT) return;
         if (results.length > 0 && results[0] == PackageManager.PERMISSION_GRANTED) {
             takeScreenshot();
@@ -1846,6 +1863,187 @@ private void saveScreenshot(Bitmap bitmap) {
         runOnUiThread(() -> isTakingScreenshot = false);
     }
 
+    // ====================== Save report (#207) ======================
+
+    private static final int REQUEST_STORAGE_FOR_REPORT = 2;
+    /** Shared as text when there is no file to share (Android 9 and older): Binder's limit. */
+    private static final int REPORT_SHARE_TEXT_MAX = 50_000;
+    private boolean isSavingReport;
+
+    /** Long press on Debug: the debug page's /report.txt as a file, then the Share sheet. */
+    @Override
+    public void onSaveReport() {
+        if (isSavingReport) return;
+        // Android 6-9 write to the shared Download folder: the runtime permission, like
+        // screenshots (#28); Android 10+ go through MediaStore with none
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
+                && Build.VERSION.SDK_INT < Build.VERSION_CODES.Q
+                && checkSelfPermission(android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
+                        != PackageManager.PERMISSION_GRANTED) {
+            requestPermissions(new String[] {android.Manifest.permission.WRITE_EXTERNAL_STORAGE},
+                    REQUEST_STORAGE_FOR_REPORT);
+            return;
+        }
+        startSavingReport();
+    }
+
+    private void startSavingReport() {
+        if (isSavingReport) return;
+        isSavingReport = true;
+        // The state is read on the UI thread, up to a timeout: the report is made beside it
+        new Thread(this::saveReport, "report").start();
+    }
+
+    /** On the report thread. */
+    private void saveReport() {
+        Date now = new Date();
+        String name = DebugServer.reportName(now);
+        String text;
+        Uri uri = null;
+        String where;
+        try {
+            text = DebugServer.get().reportText(now);
+            byte[] data = text.getBytes(StandardCharsets.UTF_8);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                uri = writeReportToDownloads(name, data);
+                where = Environment.DIRECTORY_DOWNLOADS + "/OpenIPC/" + name;
+            } else {
+                where = writeReportFile(name, data).getAbsolutePath();
+            }
+        } catch (IOException | RuntimeException e) {
+            Log.e(TAG, "Could not save the report", e);
+            runOnUiThread(() -> {
+                isSavingReport = false;
+                Toast.makeText(this, "Failed to save the report", Toast.LENGTH_LONG).show();
+            });
+            return;
+        }
+        Log.i(TAG, "Report saved: " + where);
+        final Uri shared = uri;
+        final String report = text;
+        final String at = where;
+        runOnUiThread(() -> {
+            isSavingReport = false;
+            Toast.makeText(this, "Report saved: " + at, Toast.LENGTH_LONG).show();
+            if (!isFinishing()) shareReport(name, shared, report, at);
+        });
+    }
+
+    /** Android 10+: Download/OpenIPC through MediaStore, no permission. */
+    @android.annotation.TargetApi(Build.VERSION_CODES.Q)
+    private Uri writeReportToDownloads(String name, byte[] data) throws IOException {
+        android.content.ContentResolver resolver = getContentResolver();
+        ContentValues values = new ContentValues();
+        values.put(MediaStore.Downloads.DISPLAY_NAME, name);
+        values.put(MediaStore.Downloads.MIME_TYPE, "text/plain");
+        values.put(MediaStore.Downloads.RELATIVE_PATH,
+                Environment.DIRECTORY_DOWNLOADS + "/OpenIPC");
+        values.put(MediaStore.Downloads.IS_PENDING, 1);
+        Uri uri = resolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, values);
+        if (uri == null) throw new IOException("MediaStore did not create " + name);
+        try {
+            try (OutputStream os = resolver.openOutputStream(uri)) {
+                if (os == null) throw new IOException("MediaStore gave no stream for " + name);
+                os.write(data);
+            }
+            // Published only when the pending flag is really cleared (Qodo on #208)
+            values.clear();
+            values.put(MediaStore.Downloads.IS_PENDING, 0);
+            if (resolver.update(uri, values, null, null) != 1) {
+                throw new IOException("MediaStore did not publish " + name);
+            }
+        } catch (IOException | RuntimeException e) {
+            try {
+                resolver.delete(uri, null, null);
+            } catch (RuntimeException ignored) {
+                // Nothing more to clean up
+            }
+            throw e;
+        }
+        return uri;
+    }
+
+    /**
+     * Android 9 and older: Download/OpenIPC with the storage permission; without it (refused,
+     * no shared storage) the app's own folder, which needs none.
+     */
+    @SuppressWarnings("deprecation")
+    private File writeReportFile(String name, byte[] data) throws IOException {
+        File shared = new File(Environment.getExternalStoragePublicDirectory(
+                Environment.DIRECTORY_DOWNLOADS), "OpenIPC");
+        try {
+            return writeFile(shared, name, data);
+        } catch (IOException | SecurityException e) {
+            Log.w(TAG, "Report: " + shared + " not writable (" + e.getMessage()
+                    + "), saving in the app's folder");
+        }
+        File own = getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS);
+        if (own == null) own = new File(getFilesDir(), "reports");
+        return writeFile(own, name, data);
+    }
+
+    /** Never over an earlier file: report-…-2.txt and so on if the name is taken (Qodo on #208). */
+    private static File writeFile(File dir, String name, byte[] data) throws IOException {
+        if (!dir.isDirectory() && !dir.mkdirs()) throw new IOException("cannot create " + dir);
+        int dot = name.lastIndexOf('.');
+        File f = new File(dir, name);
+        for (int n = 2; !f.createNewFile(); n++) {
+            if (n > 99) throw new IOException("no free name for " + name + " in " + dir);
+            f = new File(dir, name.substring(0, dot) + "-" + n + name.substring(dot));
+        }
+        try (FileOutputStream os = new FileOutputStream(f)) {
+            os.write(data);
+        }
+        return f;
+    }
+
+    /**
+     * The system Share sheet, to send the report later (Telegram, mail). The file itself on
+     * Android 10+; older versions have no FileProvider here, so the text, cut to a size an
+     * intent can carry, with where the whole file is. Skipped where nothing can take it, as
+     * on most TV boxes.
+     */
+    private void shareReport(String name, Uri uri, String text, String where) {
+        Intent send = new Intent(Intent.ACTION_SEND);
+        send.setType("text/plain");
+        send.putExtra(Intent.EXTRA_SUBJECT, "OpenIPC Decoder " + name);
+        if (uri != null) {
+            send.putExtra(Intent.EXTRA_STREAM, uri);
+            send.setClipData(ClipData.newRawUri(name, uri));
+            send.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        } else {
+            String body = text.length() <= REPORT_SHARE_TEXT_MAX ? text
+                    : text.substring(0, REPORT_SHARE_TEXT_MAX)
+                            + "\n... cut here; the whole report is in " + where + "\n";
+            send.putExtra(Intent.EXTRA_TEXT, body);
+        }
+        try {
+            // Not to this app itself: it takes shared text as a camera link (Qodo on #208)
+            boolean target = false;
+            for (android.content.pm.ResolveInfo ri
+                    : getPackageManager().queryIntentActivities(send, 0)) {
+                if (ri.activityInfo != null
+                        && !getPackageName().equals(ri.activityInfo.packageName)) {
+                    target = true;
+                    break;
+                }
+            }
+            if (!target) {
+                Log.i(TAG, "Report: no app to share it with");
+                return;
+            }
+            Intent chooser = Intent.createChooser(send, "Share report");
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                chooser.putExtra(Intent.EXTRA_EXCLUDE_COMPONENTS,
+                        new android.content.ComponentName[] {
+                                new android.content.ComponentName(this, Decoder.class)});
+            }
+            startActivity(chooser);
+        } catch (ActivityNotFoundException | SecurityException e) {
+            Log.w(TAG, "Report: cannot share it: " + e.getMessage());
+        }
+    }
+
     private void updateResolution(int width, int height) {
         if (width < 64 || height < 64) return;
         Log.d(TAG, "Resolution update: " + width + "x" + height);
@@ -2245,6 +2443,9 @@ public boolean onKeyDown(int keyCode, KeyEvent event) {
         switch (keyCode) {
             case KeyEvent.KEYCODE_DPAD_CENTER:
             case KeyEvent.KEYCODE_ENTER:
+                // A held OK toggles once: a long OK on Debug closes the menu while the key is
+                // still down, its repeats must not open it again (#207, Qodo on #208)
+                if (event.getRepeatCount() > 0) return true;
                 if (menuManager.isPopupShowing()) {
                     menuManager.dismissPopup();
                 } else {
diff --git a/android/app/src/main/java/com/openipc/decoder/LogBuffer.java b/android/app/src/main/java/com/openipc/decoder/LogBuffer.java
index 89a08c5f..775acbf0 100644
--- a/android/app/src/main/java/com/openipc/decoder/LogBuffer.java
+++ b/android/app/src/main/java/com/openipc/decoder/LogBuffer.java
@@ -51,8 +51,12 @@ void startReader() {
             while (true) {
                 Process p = null;
                 try {
-                    // No -d: dump what logcat still has, then keep following
-                    p = new ProcessBuilder("logcat", "-v", "threadtime")
+                    // No -d: dump what logcat still has, then keep following. Every line of the
+                    // app's own tag, but only Info and up from the rest of the process: graphics
+                    // libraries on some phones (mali_gralloc) log dozens of Debug lines a second
+                    // and would push the app's lines out of the ring within seconds (#187)
+                    p = new ProcessBuilder("logcat", "-v", "threadtime",
+                            "OpenIPCDecoder:V", "*:I")
                             .redirectErrorStream(true).start();
                     try (BufferedReader r = new BufferedReader(
                             new InputStreamReader(p.getInputStream(), StandardCharsets.UTF_8))) {
diff --git a/android/app/src/main/java/com/openipc/decoder/MenuManager.java b/android/app/src/main/java/com/openipc/decoder/MenuManager.java
index 87af8ee0..db5b6f72 100644
--- a/android/app/src/main/java/com/openipc/decoder/MenuManager.java
+++ b/android/app/src/main/java/com/openipc/decoder/MenuManager.java
@@ -77,6 +77,8 @@ interface Listener {
         void onShowUdp();
         /** D: debug text (resolution, codec, fps) in every multi-view cell on or off. */
         void onToggleStats();
+        /** A long press on Debug: stats and log saved as one file, then shared (#207). */
+        void onSaveReport();
         void onExit();
         /** Reset: every stored setting cleared, the app restarted as on first start (#171). */
         void onReset();
@@ -258,6 +260,18 @@ public boolean dispatchKeyEvent(KeyEvent event) {
             if (p != null) p.dismiss();
             if (listener != null) listener.onToggleStats();
         });
+        // Save report (#207), no cell of its own: the grid keeps its shape (#177). A long
+        // touch, a long OK on a remote (View does it for DPAD_CENTER and ENTER), or Menu
+        // while Debug has the focus, for remotes whose OK has no long press
+        statsBtn.setOnLongClickListener(v -> {
+            saveReport();
+            return true;
+        });
+        statsBtn.setOnKeyListener((v, keyCode, event) -> {
+            if (keyCode != KeyEvent.KEYCODE_MENU) return false;
+            if (event.getAction() == KeyEvent.ACTION_UP && !event.isCanceled()) saveReport();
+            return true;
+        });
         // UDP: the reserved UDP RTP cell full screen (#68, #87)
         final TextView udpBtn = wordItem(actionRow, "UDP", cell);
         if (udpShown) highlightItem(udpBtn);
@@ -289,6 +303,12 @@ public boolean dispatchKeyEvent(KeyEvent event) {
         focusForKeys(layout, mFocusItem);
     }
 
+    private void saveReport() {
+        PopupWindow p = mMenuPopup;
+        if (p != null) p.dismiss();
+        if (listener != null) listener.onSaveReport();
+    }
+
     private void updateCachedMenu(boolean quadEnabled, int mActive, String[] mHosts) {
         boolean single = !quadEnabled && !udpShown;
         setSingleViewItems(single);
diff --git a/android/app/src/test/java/com/openipc/decoder/DebugServerTest.java b/android/app/src/test/java/com/openipc/decoder/DebugServerTest.java
index 213f9372..5554f860 100644
--- a/android/app/src/test/java/com/openipc/decoder/DebugServerTest.java
+++ b/android/app/src/test/java/com/openipc/decoder/DebugServerTest.java
@@ -15,10 +15,12 @@
 import org.junit.Test;
 
 import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
+import java.util.Date;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
@@ -140,4 +142,75 @@ public void requestLine() throws IOException {
         assertNull(head(""));
         assertNull(head("\r\n\r\n"));
     }
+
+    // ====================== Save report (#207) ======================
+
+    @Test
+    public void reportHasHeaderStatsAndLogRedacted() {
+        Map<String, Object> stats = new LinkedHashMap<>();
+        stats.put("app", "OpenIPC Decoder");
+        // A source that forgot to redact: the whole text is redacted once more
+        stats.put("url", "rtsp://root:hunter2@192.168.1.10:554/stream=0");
+        String log = "10-15 12:00:00.000  1  2 I OpenIPCDecoder: Connecting to "
+                + "rtsp://admin:s3cret@cam/stream=0?password=pw42\n"
+                + "10-15 12:00:01.000  1  2 D OpenIPCDecoder: > Authorization: Basic cm9vdDox\n";
+        String r = DebugServer.reportText(stats, log, new Date(0), 3 * 3600 + 62);
+
+        assertTrue(r, r.startsWith("OpenIPC Decoder report\n"));
+        assertTrue(r, r.contains("\nApp: OpenIPC Decoder " + BuildConfig.VERSION_NAME + " ("
+                + BuildConfig.VERSION_CODE + "), git " + BuildConfig.GIT_HASH + "\n"));
+        assertTrue(r, r.contains("\nDevice: "));
+        assertTrue(r, r.contains("\nAndroid: "));
+        assertTrue(r, r.contains("\nTime: "));
+        assertTrue(r, r.contains("\nUptime: 3h 1m 2s\n"));
+
+        int json = r.indexOf("\n== stats.json ==\n{\n  \"app\": \"OpenIPC Decoder\",\n");
+        int logAt = r.indexOf("\n== log ==\n");
+        assertTrue(r, json > 0);
+        assertTrue(r, logAt > json);
+        assertTrue(r, r.contains("192.168.1.10:554/stream=0"));
+        assertTrue(r, r.endsWith("Authorization: Basic ***\n"));
+        for (String secret : new String[] {"hunter2", "s3cret", "admin", "pw42", "cm9vdDox",
+                "root:"}) {
+            assertFalse(secret + " in\n" + r, r.contains(secret));
+        }
+    }
+
+    @Test
+    public void reportNameAndUptime() {
+        String name = DebugServer.reportName(new Date());
+        assertTrue(name, name.matches("report-\\d{8}-\\d{6}\\.txt"));
+        assertEquals("0s", DebugServer.uptime(0));
+        assertEquals("5m 0s", DebugServer.uptime(300));
+        assertEquals("1d 0h 0m 1s", DebugServer.uptime(86401));
+    }
+
+    @Test
+    public void reportIsServedAsADownload() throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        new DebugServer().serve(out, "/report.txt", "");
+        String reply = out.toString("UTF-8");
+        int end = reply.indexOf("\r\n\r\n");
+        assertTrue(reply, end > 0);
+        String head = reply.substring(0, end + 2);
+        String body = reply.substring(end + 4);
+        assertTrue(head, head.startsWith("HTTP/1.1 200 OK\r\n"));
+        assertTrue(head, head.contains("\r\nContent-Type: text/plain; charset=utf-8\r\n"));
+        assertTrue(head, head.matches("(?s).*\r\nContent-Disposition: attachment; "
+                + "filename=\"report-\\d{8}-\\d{6}\\.txt\"\r\n.*"));
+        assertTrue(head, head.contains("\r\nContent-Length: "
+                + body.getBytes(StandardCharsets.UTF_8).length + "\r\n"));
+        assertTrue(body, body.startsWith("OpenIPC Decoder report\n"));
+        assertTrue(body, body.contains("\n== stats.json ==\n"));
+        assertTrue(body, body.contains("\n== log ==\n"));
+    }
+
+    @Test
+    public void pageLinksTheReport() throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        new DebugServer().serve(out, "/", "");
+        String page = out.toString("UTF-8");
+        assertTrue(page.contains("href=\"/report.txt\""));
+        assertFalse(page.substring(page.indexOf("\r\n\r\n") + 4).contains("\n"));
+    }
 }
diff --git a/docs/debug.md b/docs/debug.md
index e31c2f48..7e4241d0 100644
--- a/docs/debug.md
+++ b/docs/debug.md
@@ -6,6 +6,7 @@
 - [Stream checks in the single view](#stream-checks-in-the-single-view)
 - [stats.json fields](#statsjson-fields)
 - [Log](#log)
+- [Save report](#save-report)
 - [Corner text in multi-view](#corner-text-in-multi-view)
 - [Bug reports](#bug-reports)
 
@@ -19,6 +20,7 @@ While the app runs it serves its debug information over HTTP on port **8085**, f
 | `/stats.json` | the state as JSON, pretty-printed, see [fields](#statsjson-fields) |
 | `/snapshot.jpg` | a picture of the screen, see [Snapshot](#snapshot); `?labels=0`: frames only |
 | `/log` | the last 500 lines of the app's log, see [Log](#log) |
+| `/report.txt` | a header, `/stats.json` and `/log` in one file, downloaded as `report-YYYYMMDD-HHMMSS.txt`, see [Save report](#save-report) |
 
 - Only clients on the local network are answered; others get `403`. The rule and what is hidden: [security.md](security.md#debug-server).
 - `GET` only (`405` otherwise), one request per connection, `Cache-Control: no-store`.
@@ -39,7 +41,7 @@ The device's addresses are in `addresses` of `/stats.json`, and the [U cell](usa
 `http://<device>:8085/`
 
 - The snapshot fills the page, laid out like the screen, with each cell's slot, camera host, transport, size, fps and losses (in red) drawn over it. A decoded rate below 90 % of the received one is shown in orange.
-- The header shows a status dot, the version and git hash, the device time and the uptime, and links to **JSON** and **Log**.
+- The header shows a status dot, the version and git hash, the device time and the uptime, and links to **JSON**, **Log** and **Save report** (`/report.txt`).
 - **Info On / Off** hides the text over the cells (and the list below them on a narrow screen), leaving only the picture. It is **Off** until switched on; the choice is remembered in the browser.
 - **Snapshot 3 s / 5 s / 10 s**: how often the picture is refreshed (default 5 s). `/stats.json` is fetched every 1.5 s. Both only while the tab is visible.
 - On a screen narrower than 720 px the snapshot takes the full width and the cells are listed below it.
@@ -174,6 +176,30 @@ The FLOW-UFO test build ([toys.md](toys.md#flow-ufo)) adds a `flowufo` object pe
 
 `http://<device>:8085/log`: the last 500 lines of the app's own log (logcat in `threadtime` format; without the `READ_LOGS` permission logcat returns only the app's own lines), redacted as they come in. The same lines over adb: `adb logcat -s OpenIPCDecoder`. Lines worth knowing are listed in [LABORATORY.md](../LABORATORY.md#log-lines-logcat--s-openipcdecoder).
 
+## Save report
+
+One file with everything a bug report needs, the same text from the app and from the debug page:
+
+```
+OpenIPC Decoder report
+App: OpenIPC Decoder 2.11 (36), git <hash>
+Device: <manufacturer> <model>
+Android: <version> (SDK <n>)
+Time: 2026-10-15 12:00:00 +0300
+Uptime: 1h 2m 3s
+
+== stats.json ==
+{ ...the same object as /stats.json, pretty-printed... }
+
+== log ==
+...the last 500 lines of /log...
+```
+
+- **In the app**: a **long press on Debug** in the menu (on a remote: hold **OK** on Debug, or press **Menu** while Debug has the focus). The file is saved to `Download/OpenIPC/report-YYYYMMDD-HHMMSS.txt`, a toast shows its name, and the system *Share* sheet opens to send it (Telegram, mail). Where no app can take it, as on most TV boxes, there is no share sheet; the file stays in `Download/OpenIPC` (over adb: `adb pull /sdcard/Download/OpenIPC/`).
+- Android 10 and newer save through MediaStore and need no permission. Android 6–9 ask for the storage permission first; refused, the file goes to the app's own folder (`Android/data/com.openipc.decoder/files/Download/`), and the share sheet gets the text (cut at 50 000 characters) instead of the file.
+- **On the debug page**: **Save report** in the header, or `curl -OJ http://<device>:8085/report.txt`. Local-network clients only, like the other paths.
+- Redacted like `/log` and `/stats.json`, and the whole text once more: no logins or passwords.
+
 ## Corner text in multi-view
 
 **Debug** in the menu shows it in every cell; the same text is `text` in `cells`.
@@ -196,7 +222,7 @@ Examples: `1920×1080 H.265 25/25 fps` at full rate, `1920×1080 H.265 key frame
 Send, in a [GitHub issue](https://github.com/OpenIPC/decoder/issues):
 
 1. App version and git hash (menu, under **Exit**), device model and Android version.
-2. `/stats.json` and `/log` taken while the problem is visible (or after about 30 s of trying).
+2. A [report file](#save-report) saved while the problem is visible (or after about 30 s of trying): a long press on **Debug** in the menu, or **Save report** on the debug page. Attach the `.txt` file to the issue. Without it, `/stats.json` and `/log`.
 3. The camera: make, model, firmware, URL **without the password** (`user:***`), codec, resolution, transport.
 4. A screenshot or `/snapshot.jpg` if the picture is wrong.
 
diff --git a/docs/security.md b/docs/security.md
index 299ab684..d3b5d82c 100644
--- a/docs/security.md
+++ b/docs/security.md
@@ -37,6 +37,7 @@ The [debug server](debug.md) on port 8085 has no password and no encryption. It
 
 - answers only local-network clients: loopback, link-local (169.254/16, fe80::/10), the IPv4 private ranges 10/8, 172.16/12, 192.168/16, and IPv6 unique-local fc00::/7. Every other address gets `403 Forbidden: local network only`;
 - is read-only (`GET` only) and has no setting that changes the app;
+- `/report.txt` (and the report the app saves, [Save report](debug.md#save-report)) is `/stats.json` and `/log` together, redacted once more as a whole;
 - never shows a login or password: URLs, statuses and log lines are [redacted](#log-redaction), and the snapshot shows the picture and the cell texts only.
 
 Anyone on the same LAN can see the camera pictures and hosts through it. On a network you do not trust, close the app when you do not need it.
@@ -64,7 +65,7 @@ The built-in browser opens the camera's web interface with JavaScript enabled. H
 |---|---|
 | `INTERNET` | streams, WebUI, the debug server |
 | `CHANGE_WIFI_MULTICAST_STATE` | the multicast lock for multicast RTP on Wi‑Fi |
-| `WRITE_EXTERNAL_STORAGE` (Android ≤ 9), `READ_EXTERNAL_STORAGE` (≤ 12) | screenshots to `Pictures/OpenIPC` on older Android versions |
+| `WRITE_EXTERNAL_STORAGE` (Android ≤ 9), `READ_EXTERNAL_STORAGE` (≤ 12) | screenshots to `Pictures/OpenIPC` and reports to `Download/OpenIPC` on older Android versions |
 
 No location, camera, microphone or account permissions. No analytics and no Google services.
 
diff --git a/docs/toys.md b/docs/toys.md
index e9155cbb..3f967fc1 100644
--- a/docs/toys.md
+++ b/docs/toys.md
@@ -29,7 +29,7 @@ Whether a toy can be played here depends on its protocol. Toys that do offer RTS
 2. Android notices that the network has no internet and may ask *This network has no internet access. Stay connected?* Answer **yes** (and *Don't ask again*). Otherwise the phone may drop back to another Wi‑Fi or route traffic over mobile data.
 3. Mobile data may stay on, but some phones then send traffic for the toy's address over mobile data; if nothing arrives, try with mobile data off.
 4. Close the vendor app: the toy usually streams to one client only.
-5. While the phone is only on the toy's network, open the [debug pages](debug.md) on the phone itself: `http://127.0.0.1:8085/stats.json` and `http://127.0.0.1:8085/log`.
+5. While the phone is only on the toy's network, open the [debug pages](debug.md) on the phone itself: `http://127.0.0.1:8085/stats.json` and `http://127.0.0.1:8085/log`. Simpler: a **long press on Debug** in the menu [saves a report](debug.md#save-report) (stats and log in one file) to `Download/OpenIPC`; send it later, when the phone has internet again.
 
 ## FLOW-UFO
 
@@ -75,7 +75,7 @@ Open an [issue](https://github.com/OpenIPC/decoder/issues) (one per toy model) w
 2. The **vendor app**: its name, version and where it comes from (Google Play link).
 3. The phone model and Android version, the app version and hash (menu, under **Exit**).
 4. What you tried and what the app showed.
-5. `http://127.0.0.1:8085/stats.json` and `http://127.0.0.1:8085/log`, taken on the phone after about 30 s of trying.
+5. A **report file**, saved on the phone after about 30 s of trying: a long press on **Debug** in the menu writes `Download/OpenIPC/report-….txt` ([Save report](debug.md#save-report)). The toy's Wi‑Fi has no internet: save it there, leave the toy's network, then share it from the share sheet or attach the file from `Download/OpenIPC` to the issue. Without it, `http://127.0.0.1:8085/stats.json` and `http://127.0.0.1:8085/log`.
 6. A **traffic capture** while the vendor app shows video: for example with [PCAPdroid](https://github.com/emanuele-f/PCAPdroid) on the phone (no root needed), filtered to the vendor app, saved as a `.pcap` file. A minute is enough. This shows what the toy expects and sends.
 
 Do not send the vendor app itself or parts of it. The capture contains only the traffic between the phone and the toy; it has no passwords of yours if only the vendor app is captured.
diff --git a/docs/usage.md b/docs/usage.md
index b48c44fc..20970f09 100644
--- a/docs/usage.md
+++ b/docs/usage.md
@@ -44,7 +44,7 @@ The menu is one grid: the eight slots on top, two rows of four below. Every word
 | **Slides** | The playback mode: every frame, or key frames only, see [Slides](#slides). Does not change the view |
 | **Exit** | Close the app. The small text under it is the version and build hash (`v2.10, <hash>`) |
 | **Reset** | Clear all settings after a confirmation, see [Reset](#reset) |
-| **Debug** | Text in the corner of every multi-view cell (resolution, codec, decoded/received fps, key frames, status), or none |
+| **Debug** | Text in the corner of every multi-view cell (resolution, codec, decoded/received fps, key frames, status), or none. **Long press** (remote: hold **OK**, or **Menu** on Debug): [save a report](debug.md#save-report) to `Download/OpenIPC` and share it |
 | **UDP** | [The U cell](#the-u-cell) full-screen |
 
 Items that are on (Grid, Slides, Debug, UDP and the active slot) have an orange fill; the item the remote is on has a light blue frame. On a narrow screen or with a large font the labels are shortened with an ellipsis rather than clipped.