chore: Testversion 0.1.39

Co-Authored-By: Claude Opus 5.5 <[email protected]>

android/app/src/main/AndroidManifest.xml

@@ -9,6 +9,7 @@
     <uses-permission android:name="android.permission.BLUETOOTH_CONNECT"/>
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
     <uses-permission android:name="android.permission.VIBRATE"/>
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES"/>
@@ -26,11 +27,15 @@
         android:allowBackup="false"
         android:fullBackupContent="false"
         android:dataExtractionRules="@xml/data_extraction_rules">
+        <!-- Laufender Anruf: hält das Mikrofon im Hintergrund am Leben und
+             ist Pflicht für Bildschirmübertragung ab Android 14 (CallService.kt).
+             Der frühere Eintrag com.cloudwebrtc...FlutterForegroundService
+             verwies auf eine Klasse, die flutter_webrtc 1.x nicht mehr hat. -->
         <service
-            android:name="com.cloudwebrtc.webrtc.FlutterForegroundService"
+            android:name=".CallService"
             android:enabled="true"
             android:exported="false"
-            android:foregroundServiceType="mediaProjection" />
+            android:foregroundServiceType="microphone|mediaProjection" />
         <activity
             android:name=".MainActivity"
             android:exported="true"

android/app/src/main/kotlin/chat/pyramid/pyramid/CallService.kt

@@ -0,0 +1,143 @@
+package chat.pyramid.pyramid
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.Manifest
+import android.content.pm.PackageManager
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.IBinder
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
+
+/**
+ * Vordergrunddienst für laufende Anrufe (1:1 und Sprachkanäle).
+ *
+ * Warum: Android schaltet das Mikrofon einer App im Hintergrund stumm, und
+ * seit Android 14 stürzt jede Bildschirmübertragung ab, wenn vorher kein
+ * Dienst vom Typ „mediaProjection“ läuft (flutter_webrtc startet keinen).
+ * Genau das war Bernds Fehlerbild 2026-10-07: Teilen gestartet → App weg →
+ * beim Öffnen kein Anruf mehr.
+ *
+ * Typen: immer „microphone“ (ab Android 11), bei laufender Übertragung
+ * zusätzlich „mediaProjection“. Der Dienst darf mit mediaProjection erst
+ * NACH der Zustimmung des Nutzers gestartet werden – das stellt die
+ * Dart-Seite sicher (lib/core/call_foreground.dart).
+ */
+class CallService : Service() {
+    companion object {
+        private const val TAG = "PYRAMID-CALL"
+        private const val CHANNEL_ID = "pyramid_call"
+        private const val NOTIF_ID = 7301
+        private const val EXTRA_TITLE = "title"
+        private const val EXTRA_SCREEN = "screen"
+
+        // Wer auf den tatsächlichen startForeground wartet (Hauptthread).
+        // Die Bildschirmübertragung darf erst danach beginnen.
+        private val waiters = mutableListOf<(Boolean) -> Unit>()
+
+        fun whenStarted(callback: (Boolean) -> Unit) {
+            waiters.add(callback)
+        }
+
+        private fun notifyWaiters(ok: Boolean) {
+            val list = waiters.toList()
+            waiters.clear()
+            list.forEach { it(ok) }
+        }
+
+        fun start(ctx: Context, title: String, screen: Boolean) {
+            val intent = Intent(ctx, CallService::class.java)
+                .putExtra(EXTRA_TITLE, title)
+                .putExtra(EXTRA_SCREEN, screen)
+            ContextCompat.startForegroundService(ctx, intent)
+        }
+
+        fun stop(ctx: Context) {
+            ctx.stopService(Intent(ctx, CallService::class.java))
+        }
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val title = intent?.getStringExtra(EXTRA_TITLE) ?: "Pyramid"
+        val screen = intent?.getBooleanExtra(EXTRA_SCREEN, false) ?: false
+        ensureChannel()
+
+        val launch = packageManager.getLaunchIntentForPackage(packageName)?.apply {
+            addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
+        }
+        val open = launch?.let {
+            PendingIntent.getActivity(
+                this, 0, it,
+                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+            )
+        }
+        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
+            .setSmallIcon(R.drawable.ic_notification)
+            .setContentTitle(if (screen) "Bildschirm wird übertragen" else "Anruf läuft")
+            .setContentText("$title – tippen, um zurückzukehren")
+            .setOngoing(true)
+            .setOnlyAlertOnce(true)
+            .setSilent(true)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setContentIntent(open)
+            .build()
+
+        // Typ „microphone“ nur mit Mikrofon-Berechtigung (sonst verweigert
+        // Android den GANZEN Dienst – auch den für die Übertragung).
+        val micAllowed = ContextCompat.checkSelfPermission(
+            this, Manifest.permission.RECORD_AUDIO
+        ) == PackageManager.PERMISSION_GRANTED
+        val candidates = mutableListOf<Int>()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            val mic = ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+            val proj = ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION
+            if (screen) {
+                if (micAllowed) candidates.add(mic or proj)
+                candidates.add(proj)
+            } else if (micAllowed) {
+                candidates.add(mic)
+            }
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            candidates.add(if (screen) ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION else 0)
+        } else {
+            candidates.add(-1) // ohne Typ
+        }
+
+        var ok = false
+        for (type in candidates) {
+            try {
+                if (type == -1) startForeground(NOTIF_ID, notification)
+                else startForeground(NOTIF_ID, notification, type)
+                ok = true
+                break
+            } catch (e: Exception) {
+                // Nächste, schmalere Variante versuchen – lieber ohne Dienst
+                // weiter als die App abstürzen zu lassen.
+                Log.e(TAG, "startForeground fehlgeschlagen (screen=$screen, type=$type): ${e.message}")
+            }
+        }
+        if (!ok) stopSelf()
+        notifyWaiters(ok)
+        return START_NOT_STICKY
+    }
+
+    private fun ensureChannel() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val nm = getSystemService(NotificationManager::class.java)
+        if (nm.getNotificationChannel(CHANNEL_ID) != null) return
+        nm.createNotificationChannel(
+            NotificationChannel(CHANNEL_ID, "Laufende Anrufe", NotificationManager.IMPORTANCE_LOW).apply {
+                description = "Zeigt an, dass ein Anruf oder eine Bildschirmübertragung läuft."
+                setShowBadge(false)
+            }
+        )
+    }
+}

android/app/src/main/kotlin/chat/pyramid/pyramid/MainActivity.kt

@@ -97,6 +97,39 @@ class MainActivity : FlutterActivity() {
         super.configureFlutterEngine(flutterEngine)
         // Cache so ReplyReceiver can call back into Dart without starting a new engine.
         FlutterEngineCache.getInstance().put("main", flutterEngine)
+        // Anruf-Vordergrunddienst (lib/core/call_foreground.dart ↔ CallService.kt).
+        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "chat.pyramid.pyramid/call")
+            .setMethodCallHandler { call, result ->
+                when (call.method) {
+                    "start" -> {
+                        // Erst antworten, wenn der Dienst wirklich im Vordergrund
+                        // läuft (oder nach 3 s aufgeben) – eine Übertragung vor
+                        // dem startForeground würde die App abstürzen lassen.
+                        val done = java.util.concurrent.atomic.AtomicBoolean(false)
+                        val reply = { ok: Boolean ->
+                            if (done.compareAndSet(false, true)) result.success(ok)
+                        }
+                        try {
+                            CallService.whenStarted(reply)
+                            CallService.start(
+                                this,
+                                call.argument<String>("title") ?: "Pyramid",
+                                call.argument<Boolean>("screen") ?: false,
+                            )
+                            android.os.Handler(mainLooper).postDelayed({ reply(false) }, 3000)
+                        } catch (e: Exception) {
+                            // z. B. Start aus dem Hintergrund verboten (Android 12+).
+                            Log.e("PYRAMID-CALL", "CallService-Start abgelehnt: ${e.message}")
+                            reply(false)
+                        }
+                    }
+                    "stop" -> {
+                        CallService.stop(this)
+                        result.success(true)
+                    }
+                    else -> result.notImplemented()
+                }
+            }
         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, channel)
             .setMethodCallHandler { call, result ->
                 when (call.method) {

integration_test/android_screen_capture_test.dart

@@ -0,0 +1,52 @@
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter_webrtc/flutter_webrtc.dart';
+import 'package:integration_test/integration_test.dart';
+import 'package:pyramid/core/call_foreground.dart';
+
+/// Android 14+: Bildschirmübertragung darf die App nicht abstürzen lassen
+/// (Bernds Test 2026-10-07: „Teilen“ → App weg → Anruf verloren).
+///
+/// Ablauf wie im Anruf: Zustimmung → Anruf-Dienst mit mediaProjection →
+/// Mitschnitt. Der System-Dialog muss bestätigt werden (auf dem Emulator per
+/// adb, siehe docs/TESTS_UND_BENCHMARKS.md).
+///
+///   flutter test integration_test/android_screen_capture_test.dart -d emulator-5554
+///
+/// PYRAMID_SCREEN_NEGATIVE=1 (per --dart-define) überspringt den Dienst –
+/// Gegenprobe: dann stürzt die App wie früher ab.
+const _negative = bool.fromEnvironment('PYRAMID_SCREEN_NEGATIVE');
+
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+
+  testWidgets(
+    'Bildschirmübertragung startet ohne Absturz',
+    (tester) async {
+      await tester.pumpWidget(const MaterialApp(home: Scaffold()));
+      if (_negative) {
+        expect(await Helper.requestCapturePermission(), isTrue);
+      } else {
+        expect(
+          await CallForeground.prepareScreenCapture('test'),
+          isTrue,
+          reason: 'Zustimmung oder Dienststart fehlgeschlagen',
+        );
+      }
+      final stream = await navigator.mediaDevices
+          .getDisplayMedia({'video': true, 'audio': false});
+      expect(stream.getVideoTracks(), isNotEmpty);
+      await Future.delayed(const Duration(seconds: 3));
+      for (final t in stream.getTracks()) {
+        await t.stop();
+      }
+      await stream.dispose();
+      await CallForeground.screenCaptureStopped('test');
+      await CallForeground.callEnded('test');
+    },
+    skip: !Platform.isAndroid,
+    timeout: const Timeout(Duration(minutes: 3)),
+  );
+}

integration_test/live_receipts_invite_test.dart

@@ -0,0 +1,243 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:http/http.dart' as http;
+import 'package:integration_test/integration_test.dart';
+import 'package:matrix/matrix.dart';
+import 'package:pyramid/core/app_state.dart';
+import 'package:pyramid/core/matrix_client.dart';
+import 'package:pyramid/main.dart' as app;
+
+/// Live mit beiden Testkonten (Bernds Fehlerbericht 2026-10-07):
+///  1. ✓✓ erscheint LIVE, sobald der Partner liest – ohne den Chat neu zu
+///     öffnen (vorher zeichnete eine reine Lesebestätigung nichts neu).
+///  2. Einladung lässt sich direkt im Chat annehmen, danach ist der Verlauf
+///     sofort da (vorher leerer Chat bis zum App-Neustart).
+///
+/// Die App läuft mit dem Testprofil (PYRAMID_PROFILE_DIR, pyramidtest1).
+/// pyramidtest2 wird per Client-Server-API mit einem kurzlebigen Gerät
+/// gesteuert, das am Ende abgemeldet wird – andere Sitzungen (z. B. Bernds
+/// Testinstanz mit profile2) bleiben unberührt.
+///
+///   $env:PYRAMID_PROFILE_DIR="$env:USERPROFILE\.pyramid-autopilot\profile1"
+///   flutter test integration_test/live_receipts_invite_test.dart -d windows
+const _hs = 'https://steggi-matrix.work';
+
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+  final profile = Platform.environment['PYRAMID_PROFILE_DIR'];
+  final accounts = _loadAccounts();
+
+  testWidgets(
+    'Lesebestätigung live + Einladung im Chat annehmen',
+    (tester) async {
+      tester.view
+        ..physicalSize = const Size(1080, 2340)
+        ..devicePixelRatio = 2.625;
+      addTearDown(tester.view.reset);
+
+      final partner = await tester.runAsync(
+        () => _RestUser.login(accounts!['user2']!, accounts['pass2']!),
+      );
+      addTearDown(() => tester.runAsync(() => partner!.logout()));
+
+      app.main();
+      await _pumpUntil(tester, find.byType(MaterialApp));
+      final container = ProviderScope.containerOf(
+        tester.element(find.byType(MaterialApp).first),
+      );
+      final client = (await tester.runAsync(
+        () => container.read(matrixClientProvider.future),
+      ))!;
+      expect(client.userID, '@pyramidtest1:steggi-matrix.work');
+      await _pumpFor(tester, const Duration(seconds: 4));
+
+      // ── 1. Lesebestätigung live ──
+      final dm = client.rooms.firstWhere(
+        (r) =>
+            r.membership == Membership.join &&
+            r.directChatMatrixID == '@pyramidtest2:steggi-matrix.work',
+      );
+      container.read(activeRoomIdProvider.notifier).state = dm.id;
+      await _pumpFor(tester, const Duration(seconds: 4));
+
+      final text = 'Lesetest ${DateTime.now().millisecondsSinceEpoch}';
+      final eventId = await tester.runAsync(() => dm.sendTextEvent(text));
+      await _pumpUntil(tester, find.textContaining(text));
+      await _pumpFor(tester, const Duration(seconds: 3));
+      expect(
+        find.byIcon(Icons.done_rounded),
+        findsOneWidget,
+        reason: 'eigene neueste Nachricht sollte noch ✓ (ungelesen) zeigen',
+      );
+
+      await tester.runAsync(() => partner!.readReceipt(dm.id, eventId!));
+      // Ohne den Chat neu zu öffnen: ✓ wird zu ✓✓ direkt unter der Nachricht.
+      await _pumpUntil(
+        tester,
+        find.byIcon(Icons.done_rounded),
+        gone: true,
+        timeout: const Duration(seconds: 30),
+      );
+      final msgY = tester.getCenter(find.textContaining(text).first).dy;
+      final readIcons = find.byIcon(Icons.done_all_rounded).evaluate();
+      expect(
+        readIcons.any((e) {
+          final box = e.renderObject as RenderBox;
+          final y = box.localToGlobal(box.size.center(Offset.zero)).dy;
+          return y > msgY && y - msgY < 120;
+        }),
+        isTrue,
+        reason: '✓✓ erscheint nicht live unter der gelesenen Nachricht',
+      );
+
+      // ── 2. Einladung im Chat annehmen ──
+      final welcome = 'Willkommen im Einladungstest ${DateTime.now().millisecondsSinceEpoch}';
+      final inviteRoomId = await tester.runAsync(() async {
+        final id = await partner!.createRoom('Einladungstest');
+        await partner.sendText(id, welcome);
+        await partner.invite(id, client.userID!);
+        return id;
+      });
+      addTearDown(() => tester.runAsync(() => partner!.leave(inviteRoomId!)));
+
+      // Einladung kommt per Sync an → Chat öffnen (wie aus der Benachrichtigung).
+      final end = DateTime.now().add(const Duration(seconds: 30));
+      while (client.getRoomById(inviteRoomId!)?.membership != Membership.invite &&
+          DateTime.now().isBefore(end)) {
+        await _pumpFor(tester, const Duration(milliseconds: 500));
+      }
+      container.read(activeRoomIdProvider.notifier).state = inviteRoomId;
+      await _pumpUntil(tester, find.text('Annehmen'));
+      await tester.tap(find.text('Annehmen'));
+      // Ohne App-Neustart: Verlauf mit der Begrüßung erscheint.
+      await _pumpUntil(
+        tester,
+        find.textContaining(welcome),
+        timeout: const Duration(seconds: 40),
+      );
+      expect(find.text('Annehmen'), findsNothing);
+
+      // Aufräumen: Testraum verlassen + vergessen.
+      await tester.runAsync(() async {
+        final r = client.getRoomById(inviteRoomId);
+        await r?.leave();
+        await r?.forget().catchError((_) {});
+      });
+      container.read(activeRoomIdProvider.notifier).state = null;
+      await _pumpFor(tester, const Duration(seconds: 1));
+    },
+    skip: profile == null || accounts == null,
+    timeout: const Timeout(Duration(minutes: 4)),
+  );
+}
+
+Map<String, String>? _loadAccounts() {
+  final home = Platform.environment['USERPROFILE'] ?? '';
+  final file = File('$home\\.pyramid-autopilot\\test-accounts.txt');
+  if (!file.existsSync()) return null;
+  final map = <String, String>{};
+  for (final line in file.readAsLinesSync()) {
+    final t = line.trim();
+    if (t.isEmpty || t.startsWith('#')) continue;
+    final i = t.indexOf('=');
+    if (i > 0) map[t.substring(0, i)] = t.substring(i + 1);
+  }
+  return map;
+}
+
+/// Minimaler Matrix-Zugang per Client-Server-API (kurzlebiges Gerät).
+class _RestUser {
+  _RestUser(this._token);
+  final String _token;
+  int _txn = 0;
+
+  static Future<_RestUser> login(String user, String pass) async {
+    final res = await http.post(
+      Uri.parse('$_hs/_matrix/client/v3/login'),
+      headers: {'Content-Type': 'application/json'},
+      body: jsonEncode({
+        'type': 'm.login.password',
+        'identifier': {'type': 'm.id.user', 'user': user},
+        'password': pass,
+        'initial_device_display_name': 'Pyramid-Livetest (kurzlebig)',
+      }),
+    );
+    if (res.statusCode != 200) throw StateError('Login ${res.statusCode}');
+    return _RestUser(jsonDecode(res.body)['access_token'] as String);
+  }
+
+  Future<Map<String, dynamic>> _call(String method, String path,
+      [Object? body]) async {
+    final req = http.Request(method, Uri.parse('$_hs/_matrix/client/v3$path'))
+      ..headers['Authorization'] = 'Bearer $_token'
+      ..headers['Content-Type'] = 'application/json'
+      ..body = jsonEncode(body ?? {});
+    final res = await http.Response.fromStream(await req.send());
+    if (res.statusCode != 200) {
+      throw StateError('$method $path → ${res.statusCode}');
+    }
+    return jsonDecode(res.body) as Map<String, dynamic>;
+  }
+
+  String _enc(String s) => Uri.encodeComponent(s);
+
+  Future<void> readReceipt(String roomId, String eventId) => _call(
+        'POST',
+        '/rooms/${_enc(roomId)}/read_markers',
+        {'m.fully_read': eventId, 'm.read': eventId},
+      );
+
+  Future<String> createRoom(String name) async =>
+      (await _call('POST', '/createRoom', {
+        'name': name,
+        'preset': 'private_chat',
+      }))['room_id'] as String;
+
+  Future<void> sendText(String roomId, String text) => _call(
+        'PUT',
+        '/rooms/${_enc(roomId)}/send/m.room.message/t${DateTime.now().microsecondsSinceEpoch}${_txn++}',
+        {'msgtype': 'm.text', 'body': text},
+      );
+
+  Future<void> invite(String roomId, String userId) =>
+      _call('POST', '/rooms/${_enc(roomId)}/invite', {'user_id': userId});
+
+  Future<void> leave(String roomId) async {
+    try {
+      await _call('POST', '/rooms/${_enc(roomId)}/leave');
+      await _call('POST', '/rooms/${_enc(roomId)}/forget');
+    } catch (_) {}
+  }
+
+  Future<void> logout() async {
+    try {
+      await _call('POST', '/logout');
+    } catch (_) {}
+  }
+}
+
+Future<void> _pumpFor(WidgetTester tester, Duration d) async {
+  final end = DateTime.now().add(d);
+  while (DateTime.now().isBefore(end)) {
+    await tester.pump(const Duration(milliseconds: 100));
+  }
+}
+
+Future<void> _pumpUntil(
+  WidgetTester tester,
+  Finder finder, {
+  bool gone = false,
+  Duration timeout = const Duration(seconds: 60),
+}) async {
+  final end = DateTime.now().add(timeout);
+  while (DateTime.now().isBefore(end)) {
+    await tester.pump(const Duration(milliseconds: 200));
+    final found = finder.evaluate().isNotEmpty;
+    if (found != gone) return;
+  }
+  fail('Zeitüberschreitung: $finder ${gone ? "verschwindet nicht" : "nicht gefunden"}');
+}

lib/core/call_foreground.dart

@@ -0,0 +1,84 @@
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_webrtc/flutter_webrtc.dart' as rtc;
+
+/// Anruf-Vordergrunddienst auf Android (android/.../CallService.kt).
+///
+/// * Solange ein Anruf läuft, hält der Dienst das Mikrofon auch im
+///   Hintergrund aktiv (Android schaltet es sonst stumm) und zeigt eine
+///   „Anruf läuft“-Benachrichtigung, über die man zurück in die App kommt.
+/// * Für eine Bildschirmübertragung MUSS ab Android 14 vorher ein Dienst vom
+///   Typ mediaProjection laufen – und der darf erst NACH der Zustimmung des
+///   Nutzers starten. [prepareScreenCapture] erledigt beides in der richtigen
+///   Reihenfolge; flutter_webrtc benutzt danach die gespeicherte Zustimmung.
+///
+/// Beide Anrufwege (1:1 über Matrix, Sprachkanäle über LiveKit) melden sich
+/// mit eigenem Namen an; der Dienst endet erst, wenn keiner mehr läuft.
+/// Auf anderen Plattformen passiert nichts.
+class CallForeground {
+  CallForeground._();
+
+  static const _channel = MethodChannel('chat.pyramid.pyramid/call');
+  static final _owners = <String>{};
+  static final _screenOwners = <String>{};
+  static String _title = 'Pyramid';
+
+  static bool get _android => !kIsWeb && Platform.isAndroid;
+
+  /// true = Dienst läuft (bzw. wurde beendet) wie gewünscht.
+  static Future<bool> _apply() async {
+    if (!_android) return true;
+    try {
+      if (_owners.isEmpty) {
+        await _channel.invokeMethod('stop');
+        return true;
+      }
+      final ok = await _channel.invokeMethod<bool>('start', {
+        'title': _title,
+        'screen': _screenOwners.isNotEmpty,
+      });
+      return ok ?? false;
+    } catch (e) {
+      debugPrint('[CallForeground] $e');
+      return false;
+    }
+  }
+
+  /// Anruf von [owner] läuft (z. B. 'voip', 'livekit').
+  static Future<void> callStarted(String owner, {required String title}) async {
+    _owners.add(owner);
+    _title = title;
+    await _apply();
+  }
+
+  /// Anruf von [owner] ist beendet.
+  static Future<void> callEnded(String owner) async {
+    final changed = _owners.remove(owner) | _screenOwners.remove(owner);
+    if (changed) await _apply();
+  }
+
+  /// Vor einer Bildschirmübertragung auf Android: Zustimmung einholen, dann
+  /// den Dienst um „mediaProjection“ erweitern. false = Nutzer hat abgelehnt.
+  static Future<bool> prepareScreenCapture(String owner) async {
+    if (!_android) return true;
+    final granted = await rtc.Helper.requestCapturePermission();
+    if (!granted) return false;
+    _owners.add(owner);
+    _screenOwners.add(owner);
+    if (!await _apply()) {
+      // Ohne laufenden mediaProjection-Dienst würde der Mitschnitt die App
+      // abstürzen lassen – dann lieber gar nicht übertragen.
+      _screenOwners.remove(owner);
+      await _apply();
+      return false;
+    }
+    return true;
+  }
+
+  /// Übertragung von [owner] beendet – Dienst wieder ohne mediaProjection.
+  static Future<void> screenCaptureStopped(String owner) async {
+    if (_screenOwners.remove(owner)) await _apply();
+  }
+}

lib/features/call_signaling/call_signaling_service.dart

@@ -49,6 +49,11 @@ abstract class CallSignalingService extends ChangeNotifier {
 
   Future<void> changeQuality(String key);
 
+  /// Handy: Ton über den Lautsprecher (true) oder die Hörmuschel (false).
+  /// Auf dem PC ohne Bedeutung.
+  bool get isSpeakerOn => true;
+  Future<void> toggleSpeaker() async {}
+
   /// Wendet die in den Einstellungen gewählte Ausgabelautstärke auf den
   /// Remote-Stream an. Ohne [value] wird der Pref-Wert gelesen.
   Future<void> applyOutputVolume([double? value]);

lib/features/call_signaling/voip_manager.dart

@@ -4,6 +4,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter_webrtc/flutter_webrtc.dart' as rtc;
 import 'package:matrix/matrix.dart';
 import 'package:webrtc_interface/webrtc_interface.dart';
+import 'package:pyramid/core/call_foreground.dart';
 import 'package:pyramid/core/ice_servers.dart';
 import 'package:pyramid/core/settings_prefs.dart';
 import 'package:pyramid/features/call_signaling/call_signaling_service.dart';
@@ -35,6 +36,34 @@ class PyramidVoipManager extends CallSignalingService
   bool _isDeafened = false;
   bool _isUpdating = false;
   String? _selectedSourceId;
+
+  // Handy: Lautsprecher statt Hörmuschel (wie Discord). Das SDK schaltet bei
+  // Sprachanrufen auf die Hörmuschel – hält man das Handy vor sich, hört man
+  // dann praktisch nichts (Bernds Test 2026-10-07).
+  bool _speakerOn = true;
+  bool get _isMobile =>
+      !kIsWeb &&
+      (defaultTargetPlatform == TargetPlatform.android ||
+          defaultTargetPlatform == TargetPlatform.iOS);
+
+  @override
+  bool get isSpeakerOn => _speakerOn;
+
+  @override
+  Future<void> toggleSpeaker() async {
+    _speakerOn = !_speakerOn;
+    notifyListeners();
+    await _applySpeaker();
+  }
+
+  Future<void> _applySpeaker() async {
+    if (!_isMobile) return;
+    try {
+      await rtc.Helper.setSpeakerphoneOn(_speakerOn);
+    } catch (e) {
+      debugPrint('[VOIP] Lautsprecher: $e');
+    }
+  }
   String _currentQualityKey = 'hd';
 
   @override
@@ -104,6 +133,7 @@ class PyramidVoipManager extends CallSignalingService
     await _ensureRenderers();
     currentCall = call;
     _isCameraMuted = call.type == CallType.kVoice;
+    _speakerOn = true;
     _setupCallListeners(call);
     _updateInternalStates();
     notifyListeners();
@@ -120,9 +150,19 @@ class PyramidVoipManager extends CallSignalingService
           debugPrint('[VOIP] Ensuring camera is unmuted on connect');
           call.setLocalVideoMuted(false);
         }
+        _applySpeaker();
+        // Android: Mikrofon im Hintergrund + „Anruf läuft“-Benachrichtigung.
+        CallForeground.callStarted('voip',
+            title: call.room.getLocalizedDisplayname());
       }
+      if (state == CallState.kEnded) CallForeground.callEnded('voip');
       _updateRenderers();
     });
+    // Das SDK setzt bei jedem neuen eigenen Medienstrom die Hörmuschel –
+    // danach unsere Wahl erneut anwenden.
+    call.onCallEventChanged.stream.listen((event) {
+      if (event == CallStateChange.kFeedsChanged) _applySpeaker();
+    });
 
     _renderRefreshTimer?.cancel();
     _renderRefreshTimer = Timer.periodic(
@@ -259,6 +299,7 @@ class PyramidVoipManager extends CallSignalingService
       _isRemoteScreensharing = false;
       notifyListeners();
     }
+    CallForeground.callEnded('voip');
   }
 
   // ── Ausgabelautstärke (Settings-Slider "voice_output_volume") ─────────────
@@ -292,6 +333,7 @@ class PyramidVoipManager extends CallSignalingService
       currentCall = null;
       notifyListeners();
     }
+    CallForeground.callEnded('voip');
   }
 
   @override
@@ -361,6 +403,7 @@ class PyramidVoipManager extends CallSignalingService
     
     if (_isScreensharing) {
       await safeAction(() => call.setScreensharingEnabled(false));
+      await CallForeground.screenCaptureStopped('voip');
       return;
     }
 
@@ -390,6 +433,7 @@ class PyramidVoipManager extends CallSignalingService
       await currentCall!.hangup(reason: CallErrorCode.userHangup);
       currentCall = null;
     });
+    await CallForeground.callEnded('voip');
   }
 
   @override
@@ -399,6 +443,7 @@ class PyramidVoipManager extends CallSignalingService
     await _ensureRenderers();
     _isCameraMuted = !video; 
     
+    _speakerOn = true;
     debugPrint('[VOIP] Starting call in room $roomId (video=$video)');
     final call = await voip.inviteToCall(room, video ? CallType.kVideo : CallType.kVoice);
     currentCall = call;
@@ -525,6 +570,13 @@ class MediaDevicesWrapper extends MediaDevices {
 
   @override
   Future<rtc.MediaStream> getDisplayMedia(Map<String, dynamic> constraints) async {
+    // Android 14+: ohne laufenden mediaProjection-Dienst stürzt die App beim
+    // Mitschnitt ab – erst Zustimmung, dann Dienst, dann Mitschnitt.
+    if (!kIsWeb && defaultTargetPlatform == TargetPlatform.android) {
+      if (!await CallForeground.prepareScreenCapture('voip')) {
+        throw Exception('Bildschirmübertragung wurde nicht erlaubt');
+      }
+    }
     final String? sourceId = _manager._selectedSourceId;
     if (!kIsWeb && defaultTargetPlatform == TargetPlatform.windows && sourceId != null) {
       final desktopConstraints = {

lib/features/call_ui/view/avatars_controls.dart

@@ -51,6 +51,9 @@ class _CallControls extends StatelessWidget {
   final VoidCallback onToggleScreen;
   final VoidCallback onHangUp;
   final PyramidTheme pt;
+  // Handy: Lautsprecher/Hörmuschel statt „Ton aus“ (Platz in der Leiste).
+  final bool isSpeakerOn;
+  final VoidCallback? onToggleSpeaker;
 
   const _CallControls({
     required this.isMuted,
@@ -63,10 +66,15 @@ class _CallControls extends StatelessWidget {
     required this.onToggleScreen,
     required this.onHangUp,
     required this.pt,
+    this.isSpeakerOn = true,
+    this.onToggleSpeaker,
   });
 
   @override
   Widget build(BuildContext context) {
+    final platform = Theme.of(context).platform;
+    final showSpeaker = onToggleSpeaker != null &&
+        (platform == TargetPlatform.android || platform == TargetPlatform.iOS);
     return SafeArea(
       top: false,
       child: Container(
@@ -77,7 +85,15 @@ class _CallControls extends StatelessWidget {
           children: [
             _VoiceCtrlBtn(icon: isMuted ? Icons.mic_off_rounded : Icons.mic_rounded, danger: isMuted, pt: pt, onTap: onToggleMic),
             const SizedBox(width: 16),
-            _VoiceCtrlBtn(icon: isDeafened ? Icons.headset_off_rounded : Icons.headphones_rounded, danger: isDeafened, pt: pt, onTap: onToggleDeafen),
+            if (showSpeaker)
+              _VoiceCtrlBtn(
+                icon: isSpeakerOn ? Icons.volume_up_rounded : Icons.phone_in_talk_rounded,
+                active: isSpeakerOn,
+                pt: pt,
+                onTap: onToggleSpeaker!,
+              )
+            else
+              _VoiceCtrlBtn(icon: isDeafened ? Icons.headset_off_rounded : Icons.headphones_rounded, danger: isDeafened, pt: pt, onTap: onToggleDeafen),
             const SizedBox(width: 16),
             _VoiceCtrlBtn(icon: isCameraOff ? Icons.videocam_off_rounded : Icons.videocam_rounded, active: !isCameraOff, pt: pt, onTap: onToggleCam),
             const SizedBox(width: 16),

lib/features/call_ui/view/call_view.dart

@@ -17,6 +17,8 @@ class _UnifiedCallView extends StatefulWidget {
   final bool isScreenSharing;
   final Function(Offset)? onQualityMenu;
   final PyramidTheme pt;
+  final bool isSpeakerOn;
+  final VoidCallback? onToggleSpeaker;
 
   const _UnifiedCallView({
     required this.participants,
@@ -35,6 +37,8 @@ class _UnifiedCallView extends StatefulWidget {
     required this.isScreenSharing,
     this.onQualityMenu,
     required this.pt,
+    this.isSpeakerOn = true,
+    this.onToggleSpeaker,
   });
 
   @override
@@ -148,6 +152,8 @@ class _UnifiedCallViewState extends State<_UnifiedCallView> {
             onToggleScreen: widget.onToggleScreen,
             onHangUp: widget.onHangUp,
             pt: pt,
+            isSpeakerOn: widget.isSpeakerOn,
+            onToggleSpeaker: widget.onToggleSpeaker,
           ),
         ],
       ),

lib/features/call_ui/view/quality_menu.dart

@@ -3,6 +3,11 @@ part of '../voice_channel.dart';
 void _handleLiveKitScreenShare(BuildContext context, VoiceChannelService call) async {
   if (call.isScreenSharing) {
     await call.stopScreenShare();
+  } else if (Theme.of(context).platform == TargetPlatform.android ||
+      Theme.of(context).platform == TargetPlatform.iOS) {
+    // Handy: ganzer Bildschirm über die System-Zustimmung (kein
+    // Fenster-Auswähler wie am PC).
+    await call.toggleScreenShare();
   } else {
     final source = await ScreenSharePicker.show(context);
     if (source != null) await call.startScreenShare(source.id);

lib/features/call_ui/view/voice_channel_core.dart

@@ -58,6 +58,8 @@ class VoiceChannelView extends ConsumerWidget {
         isScreenSharing: voip.isScreensharing,
         onQualityMenu: (pos) => _showVoipQualityMenu(context, voip, pos),
         pt: pt,
+        isSpeakerOn: voip.isSpeakerOn,
+        onToggleSpeaker: voip.toggleSpeaker,
       );
     }
 
@@ -86,6 +88,8 @@ class VoiceChannelView extends ConsumerWidget {
       isScreenSharing: call.isScreenSharing,
       onQualityMenu: (pos) => _showLiveKitQualityMenu(context, call, pos),
       pt: pt,
+      isSpeakerOn: call.isSpeakerOn,
+      onToggleSpeaker: call.toggleSpeaker,
     );
   }
 

lib/features/chat/chat_provider.dart

@@ -10,7 +10,9 @@ import 'package:pyramid/core/matrix_client.dart';
 class TimelineNotifier extends FamilyAsyncNotifier<Timeline, String> {
   Timeline? _timeline;
   StreamSubscription<String>? _roomUpdateSub;
+  StreamSubscription<SyncUpdate>? _syncSub;
   Timer? _redecryptTimer;
+  String _receiptSig = '';
 
   @override
   Future<Timeline> build(String arg) async {
@@ -21,6 +23,7 @@ class TimelineNotifier extends FamilyAsyncNotifier<Timeline, String> {
 
     _timeline?.cancelSubscriptions();
     _roomUpdateSub?.cancel();
+    _syncSub?.cancel();
     _redecryptTimer?.cancel();
 
     final diag = ref.read(e2eeDiagnosticsProvider.notifier);
@@ -49,6 +52,28 @@ class TimelineNotifier extends FamilyAsyncNotifier<Timeline, String> {
       });
     });
 
+    // Nach jedem Sync (erst dann sind Lesebestätigungen verarbeitet – das
+    // Raum-Update kommt im SDK VORHER):
+    //  • Einladung angenommen (invite → join): Verlauf neu aufbauen; der beim
+    //    Einladen gebaute blieb sonst leer, bis man die App neu startete.
+    //  • Lesebestätigung eines anderen hat sich geändert: neu zeichnen, damit
+    //    ✓✓ live erscheint. Neue Nachrichten allein lösen _onUpdate schon aus,
+    //    eine Bestätigung ohne neue Nachricht bisher nicht.
+    final membershipAtBuild = room.membership;
+    _receiptSig = _receiptSignature(room);
+    _syncSub = client.onSync.stream.listen((_) {
+      if (membershipAtBuild != Membership.join &&
+          room.membership == Membership.join) {
+        ref.invalidateSelf();
+        return;
+      }
+      final sig = _receiptSignature(room);
+      if (sig != _receiptSig) {
+        _receiptSig = sig;
+        _onUpdate();
+      }
+    });
+
     // Ensure device keys are downloaded for all room members so outbound
     // Megolm session key sharing works on the first send.
     if (room.encrypted && client.encryptionEnabled) {
@@ -57,6 +82,7 @@ class TimelineNotifier extends FamilyAsyncNotifier<Timeline, String> {
 
     ref.onDispose(() {
       _roomUpdateSub?.cancel();
+      _syncSub?.cancel();
       _redecryptTimer?.cancel();
       _timeline?.cancelSubscriptions();
       _timeline = null;
@@ -70,6 +96,36 @@ class TimelineNotifier extends FamilyAsyncNotifier<Timeline, String> {
   }
 }
 
+/// Kurzer Fingerabdruck der Lesepositionen der anderen Mitglieder.
+String _receiptSignature(Room room) {
+  final b = StringBuffer();
+  for (final users in [
+    room.receiptState.global.otherUsers,
+    room.receiptState.mainThread?.otherUsers ?? const {},
+  ]) {
+    users.forEach((userId, data) => b
+      ..write(userId)
+      ..write('=')
+      ..write(data.eventId)
+      ..write(';'));
+  }
+  return b.toString();
+}
+
+/// Einladung annehmen und warten, bis der Raum als beigetreten
+/// synchronisiert ist – erst dann hat der Verlauf Inhalt.
+Future<void> acceptInvite(WidgetRef ref, Room room) async {
+  final client = room.client;
+  // Vor dem Beitreten anfangen zu warten, sonst kann der Sync durchrutschen.
+  final synced = client
+      .waitForRoomInSync(room.id, join: true)
+      .timeout(const Duration(seconds: 20))
+      .then<void>((_) {}, onError: (_) {});
+  await room.join();
+  await synced;
+  ref.invalidate(timelineProvider(room.id));
+}
+
 final timelineProvider =
     AsyncNotifierProvider.family<TimelineNotifier, Timeline, String>(
   TimelineNotifier.new,

lib/features/chat/view/chat_misc.dart

@@ -151,3 +151,207 @@ class _FloatingComposerArea extends StatelessWidget {
     );
   }
 }
+
+/// Einladung in diesen Chat (z. B. aus einer Benachrichtigung geöffnet):
+/// Annehmen/Ablehnen direkt hier statt eines leeren Verlaufs – vorher ging
+/// das nur in der Chatliste (Bernd 2026-10-07).
+class _InvitePanel extends ConsumerStatefulWidget {
+  final Room room;
+  final PyramidTheme pt;
+  const _InvitePanel({required this.room, required this.pt});
+
+  @override
+  ConsumerState<_InvitePanel> createState() => _InvitePanelState();
+}
+
+class _InvitePanelState extends ConsumerState<_InvitePanel> {
+  bool _busy = false;
+  String? _error;
+
+  String get _inviter {
+    final me = widget.room.client.userID;
+    final sender = me == null
+        ? null
+        : widget.room.getState(EventTypes.RoomMember, me)?.senderId;
+    if (sender == null) return 'Jemand';
+    return widget.room.unsafeGetUserFromMemoryOrFallback(sender).calcDisplayname();
+  }
+
+  Future<void> _accept() async {
+    setState(() {
+      _busy = true;
+      _error = null;
+    });
+    try {
+      await acceptInvite(ref, widget.room);
+    } catch (_) {
+      if (mounted) {
+        setState(() {
+          _busy = false;
+          _error = 'Annehmen hat nicht geklappt – bitte noch einmal versuchen.';
+        });
+      }
+    }
+  }
+
+  Future<void> _decline() async {
+    setState(() {
+      _busy = true;
+      _error = null;
+    });
+    try {
+      await widget.room.leave();
+      if (mounted) ref.read(activeRoomIdProvider.notifier).state = null;
+    } catch (_) {
+      if (mounted) {
+        setState(() {
+          _busy = false;
+          _error = 'Ablehnen hat nicht geklappt – bitte noch einmal versuchen.';
+        });
+      }
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final pt = widget.pt;
+    final isDm = widget.room.isDirectChat;
+    return Center(
+      child: SingleChildScrollView(
+        padding: const EdgeInsets.all(28),
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            Icon(
+              isDm ? Icons.person_add_alt_1_rounded : Icons.group_add_rounded,
+              size: 48,
+              color: pt.accent,
+            ),
+            const SizedBox(height: 16),
+            Text(
+              isDm
+                  ? '$_inviter möchte mit dir chatten'
+                  : '$_inviter lädt dich in „${widget.room.getLocalizedDisplayname()}“ ein',
+              textAlign: TextAlign.center,
+              style: TextStyle(
+                color: pt.fg,
+                fontSize: 17,
+                fontWeight: FontWeight.w600,
+              ),
+            ),
+            const SizedBox(height: 8),
+            Text(
+              'Nach dem Annehmen siehst du die Nachrichten und kannst antworten.',
+              textAlign: TextAlign.center,
+              style: TextStyle(color: pt.fgMuted, fontSize: 13.5),
+            ),
+            const SizedBox(height: 24),
+            if (_busy)
+              SizedBox(
+                width: 28,
+                height: 28,
+                child: CircularProgressIndicator(strokeWidth: 2.5, color: pt.accent),
+              )
+            else
+              Wrap(
+                spacing: 12,
+                runSpacing: 12,
+                alignment: WrapAlignment.center,
+                children: [
+                  OutlinedButton(
+                    onPressed: _decline,
+                    style: OutlinedButton.styleFrom(
+                      foregroundColor: pt.fgMuted,
+                      side: BorderSide(color: pt.border),
+                      padding: const EdgeInsets.symmetric(horizontal: 22, vertical: 14),
+                    ),
+                    child: const Text('Ablehnen'),
+                  ),
+                  FilledButton(
+                    onPressed: _accept,
+                    style: FilledButton.styleFrom(
+                      backgroundColor: pt.accent,
+                      foregroundColor: pt.accentFg,
+                      padding: const EdgeInsets.symmetric(horizontal: 26, vertical: 14),
+                    ),
+                    child: const Text('Annehmen'),
+                  ),
+                ],
+              ),
+            if (_error != null) ...[
+              const SizedBox(height: 14),
+              Text(_error!,
+                  textAlign: TextAlign.center,
+                  style: TextStyle(color: pt.danger, fontSize: 13)),
+            ],
+          ],
+        ),
+      ),
+    );
+  }
+}
+
+/// Handy: Läuft ein Anruf, während ein Chat offen ist, zeigt diese Leiste den
+/// Weg zurück (am PC übernimmt das die Anrufleiste in der Seitenleiste).
+/// Vorher war im Chat nirgends zu sehen, dass/wie man zurück in den Anruf
+/// kommt (Bernd 2026-10-07).
+class _ActiveCallBar extends ConsumerWidget {
+  const _ActiveCallBar();
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    if (!isMobileLayout(MediaQuery.sizeOf(context))) return const SizedBox.shrink();
+    final voip = ref.watch(callSignalingProvider);
+    final lk = ref.watch(voiceChannelProvider);
+    final voipCall = voip.currentCall;
+    final String? name;
+    if (voipCall != null && voipCall.state != CallState.kEnded) {
+      name = voipCall.room.getLocalizedDisplayname();
+    } else if (lk.isActive || lk.isConnecting) {
+      name = lk.displayName;
+    } else {
+      name = null;
+    }
+    final pt = PyramidTheme.of(context);
+    return AnimatedSize(
+      duration: motionDuration(context, 220),
+      curve: Curves.easeOutCubic,
+      child: name == null
+          ? const SizedBox(width: double.infinity)
+          : Material(
+              color: pt.online.withValues(alpha: 0.16),
+              child: InkWell(
+                onTap: () =>
+                    ref.read(viewModeProvider.notifier).state = ViewMode.voice,
+                child: Padding(
+                  padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 10),
+                  child: Row(
+                    children: [
+                      Icon(Icons.call_rounded, size: 18, color: pt.online),
+                      const SizedBox(width: 10),
+                      Expanded(
+                        child: Text(
+                          'Anruf läuft · $name',
+                          maxLines: 1,
+                          overflow: TextOverflow.ellipsis,
+                          style: TextStyle(
+                            color: pt.fg,
+                            fontSize: 14,
+                            fontWeight: FontWeight.w600,
+                          ),
+                        ),
+                      ),
+                      Text('Zurück',
+                          style: TextStyle(
+                              color: pt.online,
+                              fontSize: 13.5,
+                              fontWeight: FontWeight.w700)),
+                      Icon(Icons.chevron_right_rounded, size: 20, color: pt.online),
+                    ],
+                  ),
+                ),
+              ),
+            ),
+    );
+  }
+}

lib/features/chat/view/chat_view_core.dart

@@ -28,6 +28,11 @@ class _ChatViewState extends ConsumerState<ChatView> {
   // Fade-out of the "Neue Nachrichten" divider once the user reaches the bottom.
   bool _unreadFading = false;
   Timer? _unreadFadeTimer;
+  // So lange bleibt der Trenner stehen, nachdem man bei den neuesten
+  // Nachrichten angekommen ist (Bernd 2026-10-07: verschwand beim Öffnen aus
+  // der Benachrichtigung sofort).
+  static const _unreadDwell = Duration(seconds: 6);
+  Timer? _unreadDwellTimer;
   // Zuletzt von hier als gelesen gemeldetes Event. Verhindert, dass jeder
   // Neuaufbau erneut eine Lesebestätigung schickt, und markiert nach dem
   // Zurückkehren in die App, ab wo „Neue Nachrichten“ beginnen.
@@ -162,6 +167,7 @@ class _ChatViewState extends ConsumerState<ChatView> {
       _historyExhausted = false;
       _unreadFading = false;
       _unreadFadeTimer?.cancel();
+      _unreadDwellTimer?.cancel();
       _lastMarkedEventId = null;
       _popInAfter = null;
       _jumpEventId = null;
@@ -177,6 +183,7 @@ class _ChatViewState extends ConsumerState<ChatView> {
   @override
   void dispose() {
     _unreadFadeTimer?.cancel();
+    _unreadDwellTimer?.cancel();
     _highlightTimer?.cancel();
     _scrollCtrl.dispose();
     super.dispose();
@@ -247,10 +254,12 @@ class _ChatViewState extends ConsumerState<ChatView> {
         duration: const Duration(milliseconds: 250),
         curve: Curves.easeOut,
       );
+      _scheduleUnreadFadeIfAtNewest();
       return;
     }
     if (attempt >= 24) {
       _didScrollToUnread = true; // give up — stay at the newest messages
+      _scheduleUnreadFadeIfAtNewest();
       return;
     }
     if (attempt > 0 && attempt % 4 == 0 && _scrollCtrl.hasClients) {
@@ -275,7 +284,7 @@ class _ChatViewState extends ConsumerState<ChatView> {
     cancelNotificationForRoom(widget.roomId);
 
     final room = ref.read(roomProvider(widget.roomId));
-    if (room == null) return;
+    if (room == null || room.membership != Membership.join) return;
     if (room.markedUnread) room.markUnread(false).catchError((_) {});
     final timeline = tl ?? ref.read(timelineProvider(widget.roomId)).valueOrNull;
     final latest = timeline?.events
@@ -311,6 +320,7 @@ class _ChatViewState extends ConsumerState<ChatView> {
               .any((e) => _MessageList._isVisible(e) && e.senderId != me);
       if (hasNew) {
         _unreadFadeTimer?.cancel();
+        _unreadDwellTimer?.cancel();
         setState(() {
           _sessionFullyReadId = since;
           _sessionHasUnread = true;
@@ -318,26 +328,57 @@ class _ChatViewState extends ConsumerState<ChatView> {
         });
       }
     }
+    if (_sessionHasUnread) _scheduleUnreadFadeIfAtNewest();
     _markRead(timeline);
   }
 
+  // Neueste Nachrichten sind zu sehen: höchstens eine halbe Bildschirmhöhe
+  // hochgescrollt. (Nach dem Sprung zum Trenner steht die Liste meist ein
+  // Stück oberhalb des Endes – mit der strengen 60-px-Grenze blieb der
+  // Trenner dann für immer stehen.)
+  bool get _atNewest {
+    if (!_scrollCtrl.hasClients) return true;
+    final pos = _scrollCtrl.position;
+    return pos.pixels < 60 || pos.pixels < pos.viewportDimension * 0.5;
+  }
+
+  /// „Neue Nachrichten“-Trenner nach [_unreadDwell] weich ausblenden – nur
+  /// wenn man dann noch bei den neuesten Nachrichten ist. Wer zwischendurch
+  /// hochscrollt, behält ihn; unten angekommen beginnt die Wartezeit neu.
+  void _scheduleUnreadFade() {
+    if (!_sessionHasUnread || _unreadFading) return;
+    if (_unreadDwellTimer?.isActive ?? false) return;
+    _unreadDwellTimer = Timer(_unreadDwell, () {
+      if (!mounted || !_sessionHasUnread) return;
+      // App im Hintergrund oder weggescrollt: stehen lassen, beim nächsten
+      // Scrollen/Zurückkommen beginnt die Wartezeit neu.
+      if (!_atNewest || !ref.read(windowFocusedProvider)) return;
+      setState(() => _unreadFading = true);
+      _unreadFadeTimer?.cancel();
+      _unreadFadeTimer = Timer(const Duration(milliseconds: 900), () {
+        if (mounted) setState(() { _sessionHasUnread = false; _unreadFading = false; });
+      });
+    });
+  }
+
+  // Nach dem Sprung zum Trenner (Animation ~250 ms) prüfen: Passt alles
+  // Ungelesene auf den Bildschirm, scrollt niemand mehr – dann läuft die
+  // Verweildauer trotzdem an.
+  void _scheduleUnreadFadeIfAtNewest() {
+    Future.delayed(const Duration(milliseconds: 400), () {
+      if (mounted && _atNewest) _scheduleUnreadFade();
+    });
+  }
+
   Future<void> _onScroll() async {
     if (!_scrollCtrl.hasClients) return;
     final pixels = _scrollCtrl.position.pixels;
     final maxExtent = _scrollCtrl.position.maxScrollExtent;
 
-    if (pixels < 60) {
-      _markRead(null);
-      // Reached the newest messages → the "Neue Nachrichten" divider is no
-      // longer useful. Fade it out, then remove it.
-      if (_sessionHasUnread && !_unreadFading) {
-        setState(() => _unreadFading = true);
-        _unreadFadeTimer?.cancel();
-        _unreadFadeTimer = Timer(const Duration(milliseconds: 900), () {
-          if (mounted) setState(() { _sessionHasUnread = false; _unreadFading = false; });
-        });
-      }
-    }
+    if (pixels < 60) _markRead(null);
+    // Bei den neuesten Nachrichten angekommen → Trenner nach einer
+    // Verweildauer ausblenden.
+    if (_atNewest) _scheduleUnreadFade();
     final shouldShow = pixels > 400;
     if (shouldShow != _showScrollDown) {
       setState(() => _showScrollDown = shouldShow);
@@ -406,6 +447,9 @@ class _ChatViewState extends ConsumerState<ChatView> {
     }
 
     final isDesktop = Platform.isWindows || Platform.isMacOS || Platform.isLinux;
+    // Noch nicht beigetreten (Einladung): statt eines leeren Verlaufs gleich
+    // hier Annehmen/Ablehnen anbieten.
+    final isInvite = room?.membership == Membership.invite;
     final body = Stack(
         fit: StackFit.expand,
         children: [
@@ -476,8 +520,11 @@ class _ChatViewState extends ConsumerState<ChatView> {
                               setState(() => _pinnedOpen = !_pinnedOpen),
                         ),
                       const _ConnectionBanner(),
+                      const _ActiveCallBar(),
                       Expanded(
-                        child: Stack(
+                        child: isInvite
+                            ? _InvitePanel(room: room!, pt: pt)
+                            : Stack(
                           children: [
                             timelineAsync.when(
                               loading: () => Center(

lib/features/rooms/panel/rooms_invite_item.dart

@@ -16,7 +16,7 @@ class _InviteItemState extends ConsumerState<_InviteItem> {
   Future<void> _accept() async {
     setState(() => _accepting = true);
     try {
-      await widget.room.join();
+      await acceptInvite(ref, widget.room);
       if (mounted) {
         ref.read(activeRoomIdProvider.notifier).state = widget.room.id;
         ref.read(viewModeProvider.notifier).state = ViewMode.chat;

lib/features/rooms/rooms_panel.dart

@@ -12,6 +12,7 @@ import 'package:pyramid/core/matrix_client.dart';
 import 'package:pyramid/core/notification_content.dart' show notificationBody;
 import 'package:pyramid/core/theme.dart';
 import 'package:pyramid/features/rooms/rooms_provider.dart';
+import 'package:pyramid/features/chat/chat_provider.dart' show acceptInvite;
 import 'package:pyramid/features/call_ui/mini_call_widget.dart';
 import 'package:pyramid/features/call_signaling/call_signaling_service.dart';
 import 'package:pyramid/features/voice_channel/voice_channel_service.dart';

lib/features/voice_channel/livekit_call_manager.dart

@@ -4,6 +4,7 @@ import 'package:flutter/foundation.dart';
 import 'package:flutter_webrtc/flutter_webrtc.dart' as rtc;
 import 'package:livekit_client/livekit_client.dart';
 import 'package:matrix/matrix.dart' hide Room;
+import 'package:pyramid/core/call_foreground.dart';
 import 'package:pyramid/core/ice_servers.dart';
 import 'package:pyramid/core/livekit_token.dart';
 import 'package:pyramid/core/settings_prefs.dart';
@@ -98,8 +99,35 @@ class LiveKitCallManager extends VoiceChannelService {
 
   void _onRoomChanged() => notifyListeners();
 
+  // Handy: Lautsprecher statt Hörmuschel (wie Discord).
+  bool _speakerOn = true;
+  bool get _isMobile =>
+      !kIsWeb &&
+      (defaultTargetPlatform == TargetPlatform.android ||
+          defaultTargetPlatform == TargetPlatform.iOS);
+
+  @override
+  bool get isSpeakerOn => _speakerOn;
+
+  @override
+  Future<void> toggleSpeaker() async {
+    _speakerOn = !_speakerOn;
+    notifyListeners();
+    await _applySpeaker();
+  }
+
+  Future<void> _applySpeaker() async {
+    if (!_isMobile) return;
+    try {
+      await rtc.Helper.setSpeakerphoneOn(_speakerOn);
+    } catch (e) {
+      debugPrint('[LiveKit] Lautsprecher: $e');
+    }
+  }
+
   void _cleanUpAfterDisconnect() {
     _callGeneration++;
+    CallForeground.callEnded('livekit');
     _stopStatsLogging();
     _presenceHeartbeat?.cancel();
     _presenceHeartbeat = null;
@@ -254,6 +282,10 @@ class LiveKitCallManager extends VoiceChannelService {
       _room = room;
       isConnecting = false;
       notifyListeners();
+      _speakerOn = true;
+      unawaited(_applySpeaker());
+      // Android: Mikrofon im Hintergrund + „Anruf läuft“-Benachrichtigung.
+      unawaited(CallForeground.callStarted('livekit', title: roomDisplayName));
 
       if (voiceChannel && matrixClient != null && matrixRoomId != null) {
         await _writePresence(true);
@@ -269,6 +301,7 @@ class LiveKitCallManager extends VoiceChannelService {
             isScreenSharing = false;
             _currentScreenShareSourceId = null;
             _screenShareTrack = null;
+            CallForeground.screenCaptureStopped('livekit');
           }
           notifyListeners();
         })
@@ -487,6 +520,11 @@ class LiveKitCallManager extends VoiceChannelService {
           }
         }
         
+        // Android 14+: erst Zustimmung + mediaProjection-Dienst, sonst
+        // stürzt die App beim Mitschnitt ab.
+        if (!kIsWeb && defaultTargetPlatform == TargetPlatform.android) {
+          if (!await CallForeground.prepareScreenCapture('livekit')) return;
+        }
         await _room?.localParticipant?.setScreenShareEnabled(true);
         isScreenSharing = true;
         notifyListeners();
@@ -587,6 +625,7 @@ class LiveKitCallManager extends VoiceChannelService {
       }
     }
     try { await _room?.localParticipant?.setScreenShareEnabled(false); } catch (_) {}
+    await CallForeground.screenCaptureStopped('livekit');
     isScreenSharing = false;
     _currentScreenShareSourceId = null;
     _screenShareTrack = null;
@@ -597,6 +636,7 @@ class LiveKitCallManager extends VoiceChannelService {
   Future<void> hangUp() async {
     // Entwertet einen evtl. noch laufenden Verbindungsaufbau (s. _callGeneration).
     _callGeneration++;
+    unawaited(CallForeground.callEnded('livekit'));
     _stopStatsLogging();
     _presenceHeartbeat?.cancel();
     _presenceHeartbeat = null;

lib/features/voice_channel/voice_channel_service.dart

@@ -53,6 +53,11 @@ abstract class VoiceChannelService extends ChangeNotifier {
   Future<void> hangUp();
 
   Future<void> toggleMute();
+  /// Handy: Ton über den Lautsprecher (true) oder die Hörmuschel (false).
+  /// Auf dem PC ohne Bedeutung.
+  bool get isSpeakerOn => true;
+  Future<void> toggleSpeaker() async {}
+
   Future<void> toggleDeafen();
   Future<void> toggleCamera();
   Future<void> toggleScreenShare();

lib/widgets/mic_level_test.dart

@@ -0,0 +1,214 @@
+import 'dart:async';
+import 'dart:math' as math;
+
+import 'package:flutter/material.dart';
+import 'package:flutter_webrtc/flutter_webrtc.dart';
+import 'package:pyramid/core/settings_prefs.dart';
+import 'package:pyramid/core/theme.dart';
+
+/// Mikrofontest mit Pegelanzeige (Einstellungen → Sprache & Video).
+///
+/// Nimmt über DENSELBEN Weg wie ein Anruf auf (gewähltes Gerät aus den
+/// Einstellungen, WebRTC) und zeigt den Pegel live. Anlass: Bernds Test
+/// 2026-10-07 – das Handy hörte nichts vom PC, weil (mit Voicemeeter und
+/// vielen virtuellen Geräten) das Standardgerät nur Stille lieferte. Ohne
+/// Pegelanzeige war das nicht zu erkennen.
+///
+/// Technik: lokale Verbindung zu sich selbst (zwei PeerConnections im selben
+/// Prozess) – erst dann startet libwebrtc die Aufnahme und liefert den Pegel
+/// in den Statistiken. Es wird nichts verschickt oder gespeichert. Nach
+/// 30 Sekunden endet der Test von selbst.
+class MicLevelTest extends StatefulWidget {
+  const MicLevelTest({super.key, required this.pt, this.enabled = true});
+
+  final PyramidTheme pt;
+
+  /// false z. B. während eines Anrufs (zwei Aufnahmen gleichzeitig vermeiden).
+  final bool enabled;
+
+  @override
+  State<MicLevelTest> createState() => _MicLevelTestState();
+}
+
+class _MicLevelTestState extends State<MicLevelTest> {
+  MediaStream? _stream;
+  RTCPeerConnection? _a;
+  RTCPeerConnection? _b;
+  Timer? _poll;
+  Timer? _autoStop;
+  bool _running = false;
+  bool _starting = false;
+  double _level = 0; // 0..1 (geglättet)
+  double _peak = 0;
+  String? _error;
+
+  @override
+  void dispose() {
+    _stop(notify: false);
+    super.dispose();
+  }
+
+  Future<void> _start() async {
+    setState(() {
+      _starting = true;
+      _error = null;
+      _peak = 0;
+      _level = 0;
+    });
+    try {
+      final mic = (await VoicePrefs.loadDevices()).mic;
+      final audio = mic == null
+          ? true
+          : {
+              'deviceId': mic,
+              'optional': [
+                {'sourceId': mic},
+              ],
+            };
+      final stream = await navigator.mediaDevices
+          .getUserMedia({'audio': audio, 'video': false});
+      final a = await createPeerConnection({});
+      final b = await createPeerConnection({});
+      a.onIceCandidate = (c) => b.addCandidate(c);
+      b.onIceCandidate = (c) => a.addCandidate(c);
+      await a.addTrack(stream.getAudioTracks().first, stream);
+      final offer = await a.createOffer();
+      await a.setLocalDescription(offer);
+      await b.setRemoteDescription(offer);
+      final answer = await b.createAnswer();
+      await b.setLocalDescription(answer);
+      await a.setRemoteDescription(answer);
+      if (!mounted) {
+        await _release(stream, a, b);
+        return;
+      }
+      _stream = stream;
+      _a = a;
+      _b = b;
+      _poll = Timer.periodic(const Duration(milliseconds: 120), (_) => _read());
+      _autoStop = Timer(const Duration(seconds: 30), _stop);
+      setState(() {
+        _running = true;
+        _starting = false;
+      });
+    } catch (e) {
+      if (mounted) {
+        setState(() {
+          _starting = false;
+          _error = 'Mikrofon ließ sich nicht öffnen: ${e.toString().split('\n').first}';
+        });
+      }
+    }
+  }
+
+  Future<void> _read() async {
+    final a = _a;
+    if (a == null) return;
+    try {
+      for (final r in await a.getStats()) {
+        if (r.type != 'media-source') continue;
+        final raw = (r.values['audioLevel'] as num?)?.toDouble() ?? 0;
+        // Wurzel-Skala: leise Sprache soll sichtbar ausschlagen.
+        final shown = math.sqrt(raw.clamp(0.0, 1.0));
+        if (!mounted) return;
+        setState(() {
+          _level = _level * 0.4 + shown * 0.6;
+          _peak = math.max(_peak, shown);
+        });
+      }
+    } catch (_) {}
+  }
+
+  Future<void> _release(MediaStream? s, RTCPeerConnection? a, RTCPeerConnection? b) async {
+    for (final t in s?.getTracks() ?? <MediaStreamTrack>[]) {
+      try {
+        await t.stop();
+      } catch (_) {}
+    }
+    try {
+      await s?.dispose();
+    } catch (_) {}
+    try {
+      await a?.close();
+    } catch (_) {}
+    try {
+      await b?.close();
+    } catch (_) {}
+  }
+
+  void _stop({bool notify = true}) {
+    _poll?.cancel();
+    _autoStop?.cancel();
+    _poll = null;
+    _autoStop = null;
+    final s = _stream, a = _a, b = _b;
+    _stream = null;
+    _a = null;
+    _b = null;
+    _release(s, a, b);
+    if (notify && mounted) {
+      setState(() {
+        _running = false;
+        _level = 0;
+      });
+    } else {
+      _running = false;
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final pt = widget.pt;
+    final silent = _running && _peak < 0.02;
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        Row(
+          children: [
+            Icon(Icons.mic_rounded, size: 15, color: pt.fgMuted),
+            const SizedBox(width: 8),
+            Text('Mikrofontest',
+                style: TextStyle(color: pt.fg, fontSize: 13, fontWeight: FontWeight.w500)),
+            const Spacer(),
+            TextButton(
+              onPressed: !widget.enabled || _starting
+                  ? null
+                  : (_running ? _stop : _start),
+              child: Text(_running ? 'Beenden' : 'Testen'),
+            ),
+          ],
+        ),
+        const SizedBox(height: 6),
+        ClipRRect(
+          borderRadius: BorderRadius.circular(4),
+          child: Container(
+            height: 8,
+            color: pt.bg3,
+            alignment: Alignment.centerLeft,
+            child: AnimatedFractionallySizedBox(
+              duration: const Duration(milliseconds: 110),
+              widthFactor: _level.clamp(0.0, 1.0),
+              heightFactor: 1,
+              child: Container(color: _level > 0.85 ? pt.danger : pt.accent),
+            ),
+          ),
+        ),
+        const SizedBox(height: 6),
+        Text(
+          !widget.enabled
+              ? 'Während eines Anrufs nicht möglich.'
+              : _error ??
+                  (_running
+                      ? (silent
+                          ? 'Kein Ton zu hören – sprich etwas. Bleibt der Balken leer, oben ein anderes Mikrofon wählen.'
+                          : 'Sprich etwas – der Balken zeigt, was die anderen hören würden.')
+                      : 'Prüft das oben gewählte Mikrofon. Es wird nichts gesendet oder gespeichert.'),
+          style: TextStyle(
+            color: _error != null || silent ? pt.away : pt.fgDim,
+            fontSize: 11,
+          ),
+        ),
+      ],
+    );
+  }
+}

lib/widgets/settings/settings_voice.dart

@@ -270,6 +270,22 @@ class _VoiceSectionState extends ConsumerState<_VoiceSection> {
             ]),
             const SizedBox(height: 16),
             _SettingsGroup(title: 'Pegel', pt: pt, children: [
+              Padding(
+                padding: const EdgeInsets.symmetric(horizontal: 14, vertical: 10),
+                child: Builder(builder: (context) {
+                  final voip = ref.watch(callSignalingProvider);
+                  final lk = ref.watch(voiceChannelProvider);
+                  final inCall = voip.currentCall != null || lk.isActive;
+                  // Schlüssel je gewähltem Mikrofon: Gerätewechsel beendet
+                  // einen laufenden Test (sonst misst er das alte Gerät).
+                  return MicLevelTest(
+                    key: ValueKey('mictest:$_selectedMic'),
+                    pt: pt,
+                    enabled: !inCall,
+                  );
+                }),
+              ),
+              _Divider(pt: pt),
               Padding(
                 padding: const EdgeInsets.symmetric(horizontal: 14, vertical: 10),
                 child: Column(

lib/widgets/settings_modal.dart

@@ -36,6 +36,7 @@ import 'package:pyramid/widgets/update_download_dialog.dart';
 import 'package:url_launcher/url_launcher.dart';
 import 'package:pyramid/widgets/banner_crop_dialog.dart';
 import 'package:pyramid/widgets/hover_region.dart';
+import 'package:pyramid/widgets/mic_level_test.dart';
 import 'package:pyramid/widgets/mxc_image.dart';
 import 'package:pyramid/widgets/pyramid_loader.dart';
 

pubspec.yaml

@@ -1,7 +1,7 @@
 name: pyramid
 description: A flexible Matrix client with resizable panel layout.
 publish_to: none
-version: 0.1.38+39
+version: 0.1.39+40
 environment:
   sdk: ">=3.11.1 <4.0.0"
 

scripts/test.ps1

@@ -109,15 +109,26 @@ if ($Ui) {
     $uiProfile = Join-Path $env:USERPROFILE ".pyramid-autopilot\profile1"
     if (-not (Test-Path (Join-Path $uiProfile "pyramid.sqlite"))) {
         Add-Skipped "UI-Durchlauf (Handy-Format)" "Testprofil fehlt: $uiProfile"
-    } elseif (Get-Process pyramid -ErrorAction SilentlyContinue) {
-        # Nie zwei Matrix-Clients auf derselben DB – und Bernds Fenster nicht stören.
-        Add-Skipped "UI-Durchlauf (Handy-Format)" "Pyramid läuft gerade – erst beenden"
+    } elseif (Get-Process pyramid -ErrorAction SilentlyContinue |
+              Where-Object { $_.Path -like "*\build\windows\*" }) {
+        # Nie zwei Matrix-Clients auf derselben DB: ein noch laufender Testlauf
+        # (Build-Ordner) nutzt profile1. Bernds echte Pyramid und seine
+        # Testinstanz (profile2, C:\Users\nordm\pyramid-testinstanz) stören nicht.
+        Add-Skipped "UI-Durchlauf (Handy-Format)" "Ein Testlauf läuft noch – erst beenden"
     } else {
         $env:PYRAMID_PROFILE_DIR = $uiProfile
         try {
             Invoke-Step "UI-Durchlauf (Handy-Format, Testprofil)" {
                 flutter test integration_test/mobile_ui_screens_test.dart -d windows
             }
+            $accounts = Join-Path $env:USERPROFILE ".pyramid-autopilot\test-accounts.txt"
+            if (Test-Path $accounts) {
+                Invoke-Step "Live: Lesebestätigung + Einladung (2 Testkonten)" {
+                    flutter test integration_test/live_receipts_invite_test.dart -d windows
+                }
+            } else {
+                Add-Skipped "Live: Lesebestätigung + Einladung" "test-accounts.txt fehlt"
+            }
         } finally {
             Remove-Item Env:PYRAMID_PROFILE_DIR -ErrorAction SilentlyContinue
         }

windows/runner/main.cpp

@@ -27,7 +27,14 @@ int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev,
   FlutterWindow window(project);
   Win32Window::Point origin(10, 10);
   Win32Window::Size size(1280, 720);
-  if (!window.Create(L"Pyramid", origin, size)) {
+  // Testprofil (PYRAMID_PROFILE_DIR, z. B. die Testinstanz mit einem
+  // Testkonto) im Fenstertitel kenntlich machen, damit sie nicht mit der
+  // echten Pyramid verwechselt wird. Ohne die Variable bleibt alles wie immer.
+  wchar_t profile_probe[2] = {0};
+  const bool test_profile =
+      ::GetEnvironmentVariableW(L"PYRAMID_PROFILE_DIR", profile_probe, 2) > 0;
+  if (!window.Create(test_profile ? L"Pyramid - TESTINSTANZ" : L"Pyramid",
+                     origin, size)) {
     return EXIT_FAILURE;
   }
   window.SetQuitOnClose(true);