From 1332c35884a6eb60f6e9cdc6cd938ff4d0c90d30 Mon Sep 17 00:00:00 2001 From: zjs81 Date: Thu, 5 Nov 2026 23:35:27 -0700 Subject: [PATCH] Add channel message filter for spam and repeated messages Client-side filter for channel messages, with no model download: - User rules on message text and/or sender name (contains, whole word, exact), normalised for case, accents, zero-width and look-alike letters. - Automatic checks: repeated characters, same-sender repeats within 10 minutes, and the same sentence (>= 6 words) from 3+ senders within 30 minutes. Windows use send times, so synced history is not a flood. - On-device n-gram classifier trained by Mark as spam / Not spam taps. Filtered messages are kept, never notify or count as unread, are not auto-translated or used for channel previews, and are concealed in reply quotes. They show as a calm, collapsible placeholder that animates open and closed, or can be hidden completely. Includes a Filtered messages list, per-channel toggle, settings screen, translations for all locales and documentation. --- CLAUDE.md | 5 +- README.md | 1 + documentation/README.md | 2 + documentation/channels.md | 5 + documentation/chat-and-messaging.md | 2 + documentation/message-filter.md | 109 ++++ documentation/notifications.md | 2 +- documentation/settings.md | 4 + lib/connector/meshcore_connector.dart | 228 +++++++- lib/l10n/app_bg.arb | 61 +- lib/l10n/app_de.arb | 61 +- lib/l10n/app_en.arb | 262 +++++++++ lib/l10n/app_es.arb | 113 +++- lib/l10n/app_fr.arb | 61 +- lib/l10n/app_hu.arb | 113 +++- lib/l10n/app_it.arb | 61 +- lib/l10n/app_ja.arb | 267 ++++++++- lib/l10n/app_ko.arb | 267 ++++++++- lib/l10n/app_localizations.dart | 336 +++++++++++ lib/l10n/app_localizations_bg.dart | 217 ++++++- lib/l10n/app_localizations_de.dart | 218 ++++++- lib/l10n/app_localizations_en.dart | 205 +++++++ lib/l10n/app_localizations_es.dart | 213 ++++++- lib/l10n/app_localizations_fr.dart | 217 ++++++- lib/l10n/app_localizations_hu.dart | 213 ++++++- lib/l10n/app_localizations_it.dart | 217 ++++++- lib/l10n/app_localizations_ja.dart | 205 ++++++- lib/l10n/app_localizations_ko.dart | 203 ++++++- lib/l10n/app_localizations_nl.dart | 215 ++++++- lib/l10n/app_localizations_pl.dart | 219 ++++++- lib/l10n/app_localizations_pt.dart | 211 ++++++- lib/l10n/app_localizations_ru.dart | 221 ++++++- lib/l10n/app_localizations_sk.dart | 215 ++++++- lib/l10n/app_localizations_sl.dart | 219 ++++++- lib/l10n/app_localizations_sv.dart | 214 ++++++- lib/l10n/app_localizations_uk.dart | 224 ++++++- lib/l10n/app_localizations_zh.dart | 201 ++++++- lib/l10n/app_nl.arb | 61 +- lib/l10n/app_pl.arb | 267 ++++++++- lib/l10n/app_pt.arb | 113 +++- lib/l10n/app_ru.arb | 61 +- lib/l10n/app_sk.arb | 113 +++- lib/l10n/app_sl.arb | 267 ++++++++- lib/l10n/app_sv.arb | 113 +++- lib/l10n/app_uk.arb | 61 +- lib/l10n/app_zh.arb | 113 +++- lib/main.dart | 8 + lib/models/channel_message.dart | 15 + lib/models/message_filter.dart | 225 +++++++ lib/screens/channel_chat_screen.dart | 550 ++++++++++++++++-- .../channel_chat_transcript_grouping.dart | 198 +++++++ lib/screens/channels_screen.dart | 28 +- lib/screens/filtered_messages_screen.dart | 256 ++++++++ .../message_filter_settings_screen.dart | 404 +++++++++++++ lib/screens/settings_screen.dart | 35 +- .../message_filter/duplicate_tracker.dart | 145 +++++ .../message_filter_service.dart | 394 +++++++++++++ .../message_filter/message_filter_text.dart | 221 +++++++ .../message_filter/ngram_spam_classifier.dart | 230 ++++++++ lib/storage/channel_message_store.dart | 4 + lib/storage/message_filter_store.dart | 104 ++++ lib/widgets/filter_rule_dialog.dart | 198 +++++++ lib/widgets/filtered_message_ghost.dart | 396 +++++++++++++ .../connector/message_filter_ingest_test.dart | 374 ++++++++++++ test/models/channel_message_filter_test.dart | 57 ++ ...channel_chat_transcript_grouping_test.dart | 280 +++++++++ ...filtered_messages_screen_helpers_test.dart | 77 +++ .../message_filter_settings_screen_test.dart | 239 ++++++++ .../duplicate_tracker_test.dart | 283 +++++++++ .../message_filter_service_test.dart | 307 ++++++++++ .../message_filter_text_test.dart | 155 +++++ .../ngram_spam_classifier_test.dart | 149 +++++ test/storage/message_filter_store_test.dart | 104 ++++ test/widgets/filtered_message_ghost_test.dart | 265 +++++++++ untranslated.json | 104 +--- 75 files changed, 12527 insertions(+), 254 deletions(-) create mode 100644 documentation/message-filter.md create mode 100644 lib/models/message_filter.dart create mode 100644 lib/screens/channel_chat_transcript_grouping.dart create mode 100644 lib/screens/filtered_messages_screen.dart create mode 100644 lib/screens/message_filter_settings_screen.dart create mode 100644 lib/services/message_filter/duplicate_tracker.dart create mode 100644 lib/services/message_filter/message_filter_service.dart create mode 100644 lib/services/message_filter/message_filter_text.dart create mode 100644 lib/services/message_filter/ngram_spam_classifier.dart create mode 100644 lib/storage/message_filter_store.dart create mode 100644 lib/widgets/filter_rule_dialog.dart create mode 100644 lib/widgets/filtered_message_ghost.dart create mode 100644 test/connector/message_filter_ingest_test.dart create mode 100644 test/models/channel_message_filter_test.dart create mode 100644 test/screens/channel_chat_transcript_grouping_test.dart create mode 100644 test/screens/filtered_messages_screen_helpers_test.dart create mode 100644 test/screens/message_filter_settings_screen_test.dart create mode 100644 test/services/message_filter/duplicate_tracker_test.dart create mode 100644 test/services/message_filter/message_filter_service_test.dart create mode 100644 test/services/message_filter/message_filter_text_test.dart create mode 100644 test/services/message_filter/ngram_spam_classifier_test.dart create mode 100644 test/storage/message_filter_store_test.dart create mode 100644 test/widgets/filtered_message_ghost_test.dart diff --git a/CLAUDE.md b/CLAUDE.md index 9cad1ca8..d9857890 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -41,6 +41,7 @@ For Linux, use `nix develop`; see [Linux with Nix](README.md#linux-with-nix) for | Route scoring/history | `lib/services/path_history_service.dart` | | Preferences and JSON stores | `lib/storage/` | | Region list and channel/default assignments | `lib/storage/region_store.dart`, `lib/storage/channel_region_store.dart` | +| Message filter (rules, duplicate/spam checks, on-device classifier) | `lib/services/message_filter/`, `lib/models/message_filter.dart`, `lib/storage/message_filter_store.dart`, `lib/screens/message_filter_settings_screen.dart`, `lib/screens/filtered_messages_screen.dart` | | Translation models/inference | `lib/services/translation_service.dart` | | Image models/inference and GRP_DATA chunks | `lib/services/image_codec_service.dart`, `lib/services/image_chunk_transport.dart` | | Image reassembly and file persistence | `lib/services/received_image_store.dart`, `lib/services/received_image_blob_store_io.dart` | @@ -48,7 +49,7 @@ For Linux, use `nix develop`; see [Linux with Nix](README.md#linux-with-nix) for | Screens and reusable UI | `lib/screens/`, `lib/widgets/` | | Localization | `lib/l10n/` (18 locales) | -`Provider`/`ChangeNotifier` drives UI state. `main.dart` wires `MeshTheme.light()` and `MeshTheme.dark()` and uses the saved theme preference. Its `MultiProvider` exposes `MeshCoreConnector`, `MessageRetryService`, `PathHistoryService`, `AppSettingsService`, `BleDebugLogService`, `AppDebugLogService`, `ChatTextScaleService`, `TranslationService`, `UiViewStateService`, `StorageService` (plain `Provider`), `MapTileCacheService`, `TimeoutPredictionService`, `ImageCodecService`, and `ReceivedImageStore`; screens read them with `Consumer`, `context.watch()`, or `context.read()`. +`Provider`/`ChangeNotifier` drives UI state. `main.dart` wires `MeshTheme.light()` and `MeshTheme.dark()` and uses the saved theme preference. Its `MultiProvider` exposes `MeshCoreConnector`, `MessageRetryService`, `PathHistoryService`, `AppSettingsService`, `BleDebugLogService`, `AppDebugLogService`, `ChatTextScaleService`, `TranslationService`, `UiViewStateService`, `StorageService` (plain `Provider`), `MapTileCacheService`, `TimeoutPredictionService`, `ImageCodecService`, `ReceivedImageStore`, and `MessageFilterService`; screens read them with `Consumer`, `context.watch()`, or `context.read()`. Most JSON stores scope keys by the first 10 hex chars of the connected device's public key, so per-radio data stays isolated; some preferences, including the saved region-name list, are global. Model bundles, received images, and caches use files. @@ -68,4 +69,4 @@ Android builds currently include ARM64 only and use Java 17. iOS targets 16.4. R ## Documentation -Use the [feature index](documentation/README.md), [regions](documentation/regions.md), [image messages](documentation/image-messages.md), and [routing reference](documentation/routing-paths.md). Keep protocol details in the canonical reference rather than maintaining competing command tables. +Use the [feature index](documentation/README.md), [regions](documentation/regions.md), [image messages](documentation/image-messages.md), [message filter](documentation/message-filter.md), and [routing reference](documentation/routing-paths.md). Keep protocol details in the canonical reference rather than maintaining competing command tables. diff --git a/README.md b/README.md index dc07feb1..a5dbc717 100644 --- a/README.md +++ b/README.md @@ -43,6 +43,7 @@ See the [user documentation](documentation/README.md), [connection guide](docume - **Direct Messaging**: Private encrypted conversations with individual contacts - **Channels**: Public, hashtag, private, and community channels - **Mesh Images**: Send compressed images in channel chat with optional recovery packets ([guide](documentation/image-messages.md)) +- **Message Filter**: Hide spam and repeated channel messages with your own rules and on-device learning ([guide](documentation/message-filter.md)) - **Regions**: Scope channel floods and reply using a message’s known region ([guide](documentation/regions.md)) - **Translation**: Optional on-device incoming and pre-send translation - **Contact Management**: Organize contacts, track last seen times, and manage conversation history diff --git a/documentation/README.md b/documentation/README.md index 917edf1b..683894b9 100644 --- a/documentation/README.md +++ b/documentation/README.md @@ -30,6 +30,7 @@ MeshCore Open is an open-source Flutter client for MeshCore LoRa mesh networking 17. [Review Mode](review-mode.md) - Simulated radio and reviewer instructions for Google Play and App Store review 18. [Network Map](network-map.md) - Online repeater map, adding and managing repeaters from it, opt-in uploads, and hiding a repeater 19. [Themes](themes.md) - Color themes, custom icons and map markers, chat backgrounds, automatic holiday themes, and holiday message animations +20. [Message Filter](message-filter.md) - Hide spam and repeated channel messages with your own rules, automatic checks, and learning from Spam taps, all on the device ## App Overview @@ -45,6 +46,7 @@ MeshCore Open connects to MeshCore LoRa mesh radios over BLE, USB, or TCP. Once - **Configure radio settings** including frequency, power, bandwidth, and spreading factor - **Cache offline maps** for use without internet connectivity - **Analyze line-of-sight** between nodes with terrain elevation profiles +- **Filter spam** in channels with your own rules and automatic on-device checks - **Use Android Auto** to hear new messages and reply by voice while driving (Android) ## What needs internet? diff --git a/documentation/channels.md b/documentation/channels.md index 3c24f706..f3dc9d6e 100644 --- a/documentation/channels.md +++ b/documentation/channels.md @@ -101,6 +101,10 @@ Messages also show a region label when known, independently of message tracing. - **URL image previews** when enabled per channel; content is fetched over the internet - **Reactions** displayed as emoji pills below target messages +### Message Filter + +The app bar overflow menu (⋮) has **Filter messages in this channel** (shown while the master switch is on) to turn the [message filter](message-filter.md) on or off for just this channel. Hidden messages do not count as unread, notify, or appear in the channel list preview. + ### Replies (Channel Chat Only) - **Mobile**: Swipe an **incoming** message left to trigger reply (with haptic feedback). You cannot swipe your own outgoing messages. Swipe reply is not available on desktop. @@ -128,6 +132,7 @@ Where your radio only hears nearby repeaters, turn on **Also count different nea | Reply | All messages | Triggers reply mode | | Path | All messages | Opens message path view | | Add Reaction | Incoming messages only | Opens emoji picker (cannot react to your own messages) | +| Mark as spam / Filter this sender / Filter messages like this… | Incoming messages (when filtering is on for the channel) | Hides spam; see [Message filter](message-filter.md) | | Copy | All messages | Copies text to clipboard | | Mark as Unread | Incoming messages only | Marks this message and all subsequent incoming messages as unread | | Delete | All messages | Removes locally (not from mesh) | diff --git a/documentation/chat-and-messaging.md b/documentation/chat-and-messaging.md index 8763b101..8c47e507 100644 --- a/documentation/chat-and-messaging.md +++ b/documentation/chat-and-messaging.md @@ -126,6 +126,8 @@ Add emoji reactions to incoming messages (not your own): | Retry | Failed outgoing messages | Re-sends the message | | Open chat with sender | Room server chats | Opens 1:1 chat with the message sender | +In channel chats the menu also offers **Mark as spam**, **Filter this sender** and **Filter messages like this…**; see [Message filter](message-filter.md). Direct messages are never filtered. + ## Image and translation setup Enable URL images in the contact’s chat settings to preview supported image links; see [URL images](additional-features.md#url-image-previews). Images and files can also be uploaded to a configured IPFS provider from the **+** menu in direct or channel chat; the resulting URL is sent as ordinary text. See [sharing via IPFS](additional-features.md#share-an-image-via-ipfs) and [IPFS provider configuration](settings.md#ipfs-provider-configuration). Mesh image packets are currently sent through channel chat, not the direct-message composer. Set up translation and download a model in [App Settings](settings.md#translation) before using incoming or pre-send translation. diff --git a/documentation/message-filter.md b/documentation/message-filter.md new file mode 100644 index 00000000..5de465df --- /dev/null +++ b/documentation/message-filter.md @@ -0,0 +1,109 @@ +# Message Filter + +The message filter hides spam and repeated messages in channel chats. It runs entirely on your phone or computer: nothing is downloaded, no AI model or internet connection is needed, and nothing is sent over the mesh. Filtered messages are never deleted. You can always view them again. + +## Overview + +- Works on **channel messages only**. Direct messages are never filtered. +- Your own messages, reactions, GIFs and location pins are never filtered. +- Filtering is on by default, with sensible automatic checks. +- You can add your own rules, tell the app what is spam, and turn filtering off for a single channel. + +## How to Access + +- **Settings → Message filter**: the full settings screen (listed under App Settings on the Settings screen). +- **Channel chat → ⋮ menu → Filter messages in this channel**: turn filtering on or off for that channel only. +- **Long-press a message** in a channel chat for the Mark as spam, Filter this sender and Filter messages like this… actions. + +## How it works + +Each new incoming channel message is checked in this order. The first check that matches decides: + +1. **Sender rule**: one of your rules matches the sender's name. +2. **Text rule**: one of your rules matches the message text. +3. **Repeated characters** (automatic): the same character 8 or more times in a row, such as "aaaaaaaa" or "!!!!!!!!". +4. **Repeated messages** (automatic): + - The **same sender** sends the same message again within 10 minutes. + - The **same text from 3 or more different senders** within 30 minutes. This only applies to longer messages, at least 10 characters and at least 6 words, so short greetings such as "Happy New Year!" are never caught. +5. **Learned from your Spam taps** (automatic): the app compares the message with messages you marked as spam. This needs at least 2 messages marked as spam and 80% confidence. + +Details worth knowing: + +- Time windows use the time the message was **sent**, not when it reached your phone. History that is synced after you reconnect is not mistaken for a flood. +- Rules ignore capital letters, accents, zero-width (invisible) characters and look-alike letters (for example Cyrillic or Greek letters that look like Latin ones, or fullwidth letters), so spammers cannot easily sneak around a rule. +- Repeated-message checks also ignore punctuation, emoji and `@[name]` mentions. +- A reply's leading `@[name]` mention is not part of the text that is checked. + +## Marking messages yourself + +Long-press (or right-click) an incoming channel message: + +| Action | What it does | +|---|---| +| **Mark as spam** | Hides the message now and teaches the automatic filter ("Marked as spam"). | +| **Not spam** | Shown instead of Mark as spam on a filtered message. Shows it again, stops the same text being caught as a repeat in this channel while the app is running, and teaches the filter ("Marked as not spam"). | +| **Filter this sender** | After a confirmation ("Hide all messages from ...?"), adds a Sender name rule with the Exact match for that name. | +| **Filter messages like this…** | Opens the rule editor with the message text filled in, so you can shorten it to the key phrase and choose how to match. | + +These actions are not offered on your own messages, on GIFs or location pins, or in channels where filtering is off. + +## Your rules + +In **Message filter → Your rules**, tap **Add rule**. Each rule has: + +| Option | Choices | +|---|---| +| **Word, phrase or name** | The text to look for (for example `meshos`). | +| **Look in** | **Message text**, **Sender name**, or **Both**. | +| **Match** | **Contains** (anywhere), **Whole word** (not inside a longer word) or **Exact** (the whole text or name). | + +Tap a rule to edit it. Each rule has its own on/off switch and a delete button. Deleting shows "Rule deleted" with an Undo button. + +## How filtered messages look + +Under **Message filter → Filtered messages** choose one of two display modes: + +- **Show a small placeholder** (default): hidden messages are replaced by a small line, "Hidden message · Tap to view". Several hidden messages in a row collapse into one line, for example "3 hidden messages · Tap to view". + - Tap the line to open it with a short animation. The header then reads "Showing hidden message · Tap to hide"; tap it again to close. + - Each opened message shows why it was filtered (for example `Filtered: matches "meshos"`, `Filtered: repeated message` or `Filtered: you marked this as spam`) with **Not spam** and **Hide** buttons. +- **Hide completely**: nothing is shown in the chat. "Hidden messages stay in the Filtered messages list." + +The **Filtered messages (n)** entry on the settings screen opens a list of everything that was filtered, newest first, across all channels. Tap a row to view it, or tap **Not spam** to restore it. + +Other effects of filtering: + +- Filtered messages never count as **unread** and never send a **notification**. +- They are not **auto-translated**. +- They are not used as the **last-message preview** in the Channels list; the newest message that was not hidden is shown instead. +- If someone replies to a hidden message, the quoted text in the reply is concealed ("Hidden message · Tap to view") until the original is opened. + +## Settings + +| Setting | Default | Description | +|---|---|---| +| **Filter messages** | On | Master switch. "Applies to channel messages". | +| **Show a small placeholder** / **Hide completely** | Placeholder | How filtered messages appear in chat. | +| **Your rules** | None | Your own rules (see above). | +| **Repeated messages** | On | "The same message sent again, or by several senders". | +| **Repeated characters** | On | Messages like "aaaaaaaa" or "!!!!!!!!". | +| **Learn from Spam taps** | On | Shows how many "spam and not-spam examples" the app is using. | +| **Reset learning** | | Asks for confirmation, then forgets everything learned from your Spam and Not spam taps. Your rules are kept. | + +### Channel menu + +In a channel chat, open the ⋮ menu and tick or untick **Filter messages in this channel**. This item is only shown while the master switch is on. Channels you untick are not filtered at all (no rules, no automatic checks), and their messages show normally. + +## Privacy + +Rules, settings and the examples used for learning are stored on your device in the app's preferences. They are **global**: they apply to every radio you connect, unlike most per-radio data. Nothing is uploaded and nothing is shared. The learning is a small statistical check that runs in the app itself; there is no model to download. + +## Limitations + +- **Channels only.** Direct messages and room chats are not filtered. +- **New messages only.** A new rule or a changed switch applies to messages received from then on, not to messages already in the chat. Use Mark as spam on an old message to hide it. +- **Reveal lasts while the chat is open.** Messages you open stay open until you tap the "Tap to hide" header (or Hide on one of them) or leave the chat; they collapse again next time. +- **Learning is per device.** It is not shared between your phones or computers, and it needs at least 2 Spam taps before it does anything. +- **Repeat tracking is not remembered.** The recent-message memory used for repeat checks is kept only while the app is running. +- **Filtering happens in the app.** Spam still travels over the radio channel and uses airtime; the filter only keeps it from your screen. + +See also [Channels](channels.md), [Chat & Messaging](chat-and-messaging.md), [Notifications](notifications.md) and [Settings](settings.md). diff --git a/documentation/notifications.md b/documentation/notifications.md index 535570c3..96916394 100644 --- a/documentation/notifications.md +++ b/documentation/notifications.md @@ -93,7 +93,7 @@ The app icon (iOS) or dock icon (macOS) badge shows the total unread count. It i - Stored per contact (by public key) and per channel, **scoped to the connected device's identity** (first 10 hex characters of its public key). Switching between different radios gives each its own independent unread state - **Suppressed when viewing**: Opening a chat resets the count to 0 and cancels the OS notification -- **Ignored for**: Outgoing messages, CLI messages, and repeater contacts +- **Ignored for**: Outgoing messages, CLI messages, repeater contacts, and channel messages hidden by the [message filter](message-filter.md) (these also never send a notification) - Debounced writes (500ms) to avoid excessive storage I/O during message bursts ## Notification Settings diff --git a/documentation/settings.md b/documentation/settings.md index bf380de4..eab89d9b 100644 --- a/documentation/settings.md +++ b/documentation/settings.md @@ -188,6 +188,10 @@ Controls character substitution profiles used to render Cyrillic text in Latin c --- +### Message filter + +On the Settings screen, below App Settings, **Message filter** opens a page to hide spam and repeated channel messages: a master switch, display mode, your own rules, automatic checks, and learning. See [Message Filter](message-filter.md). + ## Actions One-tap device operations: diff --git a/lib/connector/meshcore_connector.dart b/lib/connector/meshcore_connector.dart index e69b4f32..c6b2ad49 100644 --- a/lib/connector/meshcore_connector.dart +++ b/lib/connector/meshcore_connector.dart @@ -13,6 +13,7 @@ import '../models/channel.dart'; import '../models/channel_message.dart'; import '../models/companion_radio_stats.dart'; import '../models/contact.dart'; +import '../models/message_filter.dart'; import '../models/message.dart'; import '../models/path_selection.dart'; import '../models/translation_support.dart'; @@ -36,6 +37,7 @@ import '../services/image_chunk_transport.dart' senderPrefixFromKey; import '../services/image_codec_service.dart'; import '../services/received_image_store.dart'; +import '../services/message_filter/message_filter_service.dart'; import '../services/message_retry_service.dart'; import '../services/path_history_service.dart'; import '../services/app_settings_service.dart' @@ -326,6 +328,7 @@ class MeshCoreConnector extends ChangeNotifier { bool _hasLoadedChannels = false; TimeoutPredictionService? _timeoutPredictionService; TranslationService? _translationService; + MessageFilterService? _messageFilterService; ImageCodecService? _imageCodecService; // Holds the ImageReassembler, so partially received images survive across // frames (chunks of one image arrive in separate GRP_DATA frames, and via the @@ -1026,6 +1029,171 @@ class MeshCoreConnector extends ChangeNotifier { notifyListeners(); } + // ---- message filter ------------------------------------------------------- + + /// Channel id the message filter uses for [channel] (per-channel exclusion, + /// duplicate tracking and "Not spam" exemptions). + static String messageFilterChannelId(Channel channel) => + channel.storageId ?? 'slot:${channel.index}'; + + String _messageFilterChannelIdForSlot(int slot) { + final channel = _findChannelByIndex(slot); + if (channel != null) return messageFilterChannelId(channel); + return _slotChannelIds[slot] ?? 'slot:$slot'; + } + + /// Returns [message] tagged with [verdict], or unchanged when it is null. + @visibleForTesting + static ChannelMessage applyFilterVerdict( + ChannelMessage message, + FilterVerdict? verdict, + ) { + if (verdict == null) return message; + return message.copyWith( + filterReason: filterReasonToJson(verdict.reason), + filterDetail: verdict.detail, + ); + } + + /// Text the message filter sees for [message]: the stored text, i.e. + /// without a leading `@[name] ` reply mention. + static String _messageFilterText(ChannelMessage message) => + ChannelMessage.parseReplyMention(message.text)?.actualMessage ?? + message.text; + + /// Runs an incoming channel message through the message filter. Filtered + /// messages come back tagged (never dropped). Outgoing messages, reactions + /// and structured payloads pass through untouched. + ChannelMessage _applyMessageFilter(String channelId, ChannelMessage message) { + final service = _messageFilterService; + if (service == null || message.isOutgoing) return message; + final verdict = service.evaluate( + channelId: channelId, + sender: message.senderName, + text: _messageFilterText(message), + // The sender's timestamp, not arrival time: queued history synced + // after reconnecting arrives in a burst but was sent spread out. + sentAt: message.timestamp, + isReaction: message.parseReaction() != null, + ); + return applyFilterVerdict(message, verdict); + } + + /// Remembers a newly stored, unfiltered incoming message as an implicit + /// "not spam" example. Only called once per message (after dedup). + void _recordCleanChannelMessage( + ChannelMessage message, { + required bool isNew, + }) { + final service = _messageFilterService; + if (service == null || !isNew) return; + if (message.isOutgoing || message.isFiltered) return; + if (message.parseReaction() != null) return; + // The service ignores structured payloads (GIFs etc.) itself. + service.recordClean( + sender: message.senderName, + text: _messageFilterText(message), + ); + } + + /// Finds the stored message with [messageId] in [channel] and replaces it + /// with [update]'s result, scheduling a save. Returns false when the + /// message is not loaded. + /// + /// Scoped to one channel on purpose: message ids do not include the + /// channel, so the same sender posting the same text to two channels in + /// the same second gives two messages with one id. + bool _updateLoadedChannelMessageById( + Channel channel, + String messageId, + ChannelMessage Function(ChannelMessage existing) update, + ) { + final slot = _canonicalSlot(channel.index); + final messages = _channelMessages[slot]; + if (messages == null) return false; + final index = messages.indexWhere((m) => m.messageId == messageId); + if (index < 0) return false; + messages[index] = update(messages[index]); + _scheduleChannelSave(slot); + return true; + } + + /// User marked [message] in [channel] as spam: hide it and teach the + /// filter. + Future markChannelMessageSpam( + Channel channel, + ChannelMessage message, + ) async { + _updateLoadedChannelMessageById( + channel, + message.messageId, + (existing) => existing + .copyWith(clearFilter: true) + .copyWith(filterReason: filterReasonToJson(FilterReason.manual)), + ); + notifyListeners(); + // Same text intake saw (reply mention stripped), so the spam example + // replaces the clean one recorded on arrival instead of contradicting it. + await _messageFilterService?.markSpam( + sender: message.senderName, + text: _messageFilterText(message), + ); + } + + /// User marked [message] in [channel] as not spam: show it again and teach + /// the filter. + Future markChannelMessageNotSpam( + Channel channel, + ChannelMessage message, + ) async { + _updateLoadedChannelMessageById( + channel, + message.messageId, + (existing) => existing.copyWith(clearFilter: true), + ); + notifyListeners(); + final service = _messageFilterService; + if (service == null) return; + await service.markNotSpam( + channelId: messageFilterChannelId(channel), + sender: message.senderName, + text: _messageFilterText(message), + ); + } + + /// Filtered messages across all loaded channels, newest first. + List<(Channel channel, ChannelMessage message)> + recentFilteredChannelMessages({int limit = 200}) { + final result = <(Channel, ChannelMessage)>[]; + for (final entry in _channelMessages.entries) { + final channel = _findChannelByIndex(entry.key); + if (channel == null) continue; + for (final message in entry.value) { + if (message.isFiltered) result.add((channel, message)); + } + } + result.sort((a, b) => b.$2.receivedAt.compareTo(a.$2.receivedAt)); + return result.length > limit ? result.sublist(0, limit) : result; + } + + /// Newest message in [channel] that the message filter did not hide, for + /// channel-list previews. When filtering is off for [channel], filtered + /// messages are shown as normal messages and count here too. + ChannelMessage? latestVisibleChannelMessage(Channel channel) { + final messages = getChannelMessages(channel); + if (messages.isEmpty) return null; + final filterActive = + _messageFilterService?.isChannelFiltered( + messageFilterChannelId(channel), + ) ?? + false; + if (!filterActive) return messages.last; + for (var i = messages.length - 1; i >= 0; i--) { + if (!messages[i].isFiltered) return messages[i]; + } + return null; + } + /// Storage ID for [slot], or null (logged) when the slot has none, in which /// case the caller skips persistence. String? _channelIdForSlot(int slot) { @@ -1738,6 +1906,7 @@ class MeshCoreConnector extends ChangeNotifier { ImageCodecService? imageCodecService, ImageChunkTransport? imageTransport, ReceivedImageStore? receivedImageStore, + MessageFilterService? messageFilterService, void Function(ImageChunkOutcome outcome)? onImageChunk, void Function(int senderPrefix)? onImageSenderPrefix, }) { @@ -1747,6 +1916,7 @@ class MeshCoreConnector extends ChangeNotifier { _lastShowLinkImagesByDefault = _showLinkImagesByDefault; appSettingsService?.addListener(_onAppSettingsChanged); _translationService = translationService; + _messageFilterService = messageFilterService; _imageCodecService = imageCodecService; _imageTransport = imageTransport; _receivedImageStore = receivedImageStore; @@ -7687,7 +7857,10 @@ class MeshCoreConnector extends ChangeNotifier { parsed.timestamp.millisecondsSinceEpoch ~/ 1000, '${parsed.senderName}: ${parsed.text}', ); - final message = parsed.copyWith(packetHash: contentHash); + final message = _applyMessageFilter( + _messageFilterChannelIdForSlot(parsed.channelIndex!), + parsed.copyWith(packetHash: contentHash), + ); _updateContactLastMessageAtByName( message.senderName, message.timestamp, @@ -7695,9 +7868,14 @@ class MeshCoreConnector extends ChangeNotifier { pathHashWidth: message.pathHashWidth, ); final isNew = _addChannelMessage(message.channelIndex!, message); - _maybeIncrementChannelUnread(message, isNew: isNew); + _recordCleanChannelMessage(message, isNew: isNew); + // Filtered messages are stored but never count as unread, notify or + // get auto-translated. + if (!message.isFiltered) { + _maybeIncrementChannelUnread(message, isNew: isNew); + } notifyListeners(); - if (isNew && !message.isOutgoing) { + if (isNew && !message.isOutgoing && !message.isFiltered) { final msg = message; // capture for closure unawaited(() async { final translationResult = await translateChannelMessage( @@ -7769,20 +7947,25 @@ class MeshCoreConnector extends ChangeNotifier { final pktHash = computePacketHash(packet.payloadType, packet.payload); - final message = ChannelMessage( - senderKey: null, - senderName: parsed.senderName, - text: decodedText, - timestamp: DateTime.fromMillisecondsSinceEpoch(timestampRaw * 1000), - receivedAt: DateTime.now(), - isOutgoing: false, - status: ChannelMessageStatus.sent, - pathLength: packet.isFlood ? packet.hopCount : 0, - pathHashWidth: packet.pathHashWidth, - pathBytes: packet.pathBytes, - channelIndex: slot, - region: _resolveTransportRegion(packet), - packetHash: pktHash, + final message = _applyMessageFilter( + messageFilterChannelId(channel), + ChannelMessage( + senderKey: null, + senderName: parsed.senderName, + text: decodedText, + timestamp: DateTime.fromMillisecondsSinceEpoch( + timestampRaw * 1000, + ), + receivedAt: DateTime.now(), + isOutgoing: false, + status: ChannelMessageStatus.sent, + pathLength: packet.isFlood ? packet.hopCount : 0, + pathHashWidth: packet.pathHashWidth, + pathBytes: packet.pathBytes, + channelIndex: slot, + region: _resolveTransportRegion(packet), + packetHash: pktHash, + ), ); _updateContactLastMessageAtByName( @@ -7792,9 +7975,14 @@ class MeshCoreConnector extends ChangeNotifier { pathHashWidth: message.pathHashWidth, ); final isNew = _addChannelMessage(slot, message); - _maybeIncrementChannelUnread(message, isNew: isNew); + _recordCleanChannelMessage(message, isNew: isNew); + // Filtered messages are stored but never count as unread, notify + // or get auto-translated. + if (!message.isFiltered) { + _maybeIncrementChannelUnread(message, isNew: isNew); + } notifyListeners(); - if (isNew) { + if (isNew && !message.isFiltered) { // Run translation + notification asynchronously to avoid blocking unawaited(() async { final translationResult = await translateChannelMessage( @@ -8583,6 +8771,8 @@ class MeshCoreConnector extends ChangeNotifier { replyToSenderName: message.replyToSenderName ?? originalMessage!.senderName, replyToText: message.replyToText ?? originalMessage!.text, + filterReason: message.filterReason, + filterDetail: message.filterDetail, ); } } diff --git a/lib/l10n/app_bg.arb b/lib/l10n/app_bg.arb index 3993d19e..e108a8b0 100644 --- a/lib/l10n/app_bg.arb +++ b/lib/l10n/app_bg.arb @@ -3526,5 +3526,64 @@ "themes_chatBackground": "Фон на чата", "themes_chatBackgroundHelp": "Показва се в чатове, които нямат свой фон", "themes_chatBackgroundEverywhere": "Използвай във всички чатове", - "themes_chatBackgroundEverywhereHelp": "Заменя и фоновете, зададени на отделни чатове" + "themes_chatBackgroundEverywhereHelp": "Заменя и фоновете, зададени на отделни чатове", + "appSettings_showOnlineLinks": "Показвай връзките от онлайн картата", + "appSettings_showOnlineLinksSubtitle": "Показва линии между възлите от онлайн картата", + "map_showOnlineLinks": "Показвай връзките от онлайн картата", + "messageFilter_title": "Филтър за съобщения", + "messageFilter_settingsSubtitle": "Скрива спам и повтарящи се съобщения", + "messageFilter_enabled": "Филтрирай съобщенията", + "messageFilter_enabledSubtitle": "Важи за съобщенията в каналите", + "messageFilter_displayTitle": "Филтрирани съобщения", + "messageFilter_displayPlaceholder": "Показвай малък знак на мястото им", + "messageFilter_displayHide": "Скрий напълно", + "messageFilter_displayHideHelp": "Скритите съобщения остават в списъка „Филтрирани съобщения“.", + "messageFilter_rulesSection": "Твоите правила", + "messageFilter_rulesEmpty": "Още няма правила. Добави дума, фраза или име на подател, за да скриваш съобщенията, които съвпадат.", + "messageFilter_addRule": "Добави правило", + "messageFilter_editRule": "Редактирай правило", + "messageFilter_rulePattern": "Дума, фраза или име", + "messageFilter_rulePatternHint": "напр. meshos", + "messageFilter_ruleWhere": "Търси в", + "messageFilter_ruleFieldText": "Текст на съобщението", + "messageFilter_ruleFieldSender": "Име на подателя", + "messageFilter_ruleFieldBoth": "И двете", + "messageFilter_ruleMatch": "Съвпадение", + "messageFilter_ruleMatchContains": "Съдържа", + "messageFilter_ruleMatchWholeWord": "Цяла дума", + "messageFilter_ruleMatchExact": "Точно", + "messageFilter_ruleDeleted": "Правилото е изтрито", + "messageFilter_ruleSaved": "Правилото е запазено", + "messageFilter_automaticSection": "Автоматично", + "messageFilter_duplicates": "Повтарящи се съобщения", + "messageFilter_duplicatesSubtitle": "Същото съобщение, изпратено отново или от няколко подателя", + "messageFilter_repeatedCharacters": "Повтарящи се символи", + "messageFilter_repeatedCharactersSubtitle": "Съобщения като „aaaaaaaa“ или „!!!!!!!!“", + "messageFilter_learning": "Учи се от натискането на „Спам“", + "messageFilter_learningSubtitle": "{spam} примера за спам и {notSpam} примера, които не са спам", + "messageFilter_resetLearning": "Нулирай наученото", + "messageFilter_resetLearningConfirm": "Да се забрави ли всичко, научено от натискането на „Спам“ и „Не е спам“? Правилата ти се запазват.", + "messageFilter_filteredMessages": "Филтрирани съобщения ({count})", + "messageFilter_filteredMessagesEmpty": "Нищо не е филтрирано.", + "messageFilter_ghostSingle": "Скрито съобщение · Докосни, за да го видиш", + "messageFilter_ghostMany": "{count, plural, one{{count} скрито съобщение · Докосни, за да го видиш} other{{count} скрити съобщения · Докосни, за да ги видиш}}", + "messageFilter_ghostSingleExpanded": "Показва се скрито съобщение · Докосни, за да го скриеш", + "messageFilter_ghostManyExpanded": "{count, plural, one{Показва се 1 скрито съобщение · Докосни, за да го скриеш} other{Показват се {count} скрити съобщения · Докосни, за да ги скриеш}}", + "messageFilter_reasonTextRule": "Филтрирано: съвпада с „{pattern}“", + "messageFilter_reasonSenderRule": "Филтрирано: подател „{pattern}“", + "messageFilter_reasonRepeatedCharacters": "Филтрирано: повтарящи се символи", + "messageFilter_reasonDuplicate": "Филтрирано: повтарящо се съобщение", + "messageFilter_reasonCrossSenderDuplicate": "Филтрирано: същото съобщение от няколко подателя", + "messageFilter_reasonLearned": "Филтрирано: прилича на съобщения, които си отбелязал като спам", + "messageFilter_reasonManual": "Филтрирано: ти го отбеляза като спам", + "messageFilter_notSpam": "Не е спам", + "messageFilter_hideAgain": "Скрий", + "messageFilter_markSpam": "Отбележи като спам", + "messageFilter_markedSpam": "Отбелязано като спам", + "messageFilter_markedNotSpam": "Отбелязано като не е спам", + "messageFilter_filterSender": "Филтрирай този подател", + "messageFilter_filterSenderConfirm": "Да се скрият ли всички съобщения от „{name}“?", + "messageFilter_filterLikeThis": "Филтрирай съобщения като това…", + "messageFilter_channelToggle": "Филтрирай съобщенията в този канал", + "messageFilter_ghostIconTooltip": "Скрито от твоя филтър за съобщения" } diff --git a/lib/l10n/app_de.arb b/lib/l10n/app_de.arb index 1fb06197..579ded08 100644 --- a/lib/l10n/app_de.arb +++ b/lib/l10n/app_de.arb @@ -3661,5 +3661,64 @@ "themes_chatBackground": "Chat-Hintergrund", "themes_chatBackgroundHelp": "Wird in Chats gezeigt, die keinen eigenen Hintergrund haben", "themes_chatBackgroundEverywhere": "In jedem Chat verwenden", - "themes_chatBackgroundEverywhereHelp": "Ersetzt auch Hintergründe, die für einzelne Chats gesetzt wurden" + "themes_chatBackgroundEverywhereHelp": "Ersetzt auch Hintergründe, die für einzelne Chats gesetzt wurden", + "appSettings_showOnlineLinks": "Verbindungen der Online-Karte anzeigen", + "appSettings_showOnlineLinksSubtitle": "Verbindungslinien zwischen Knoten aus der Online-Karte anzeigen", + "map_showOnlineLinks": "Verbindungen der Online-Karte anzeigen", + "messageFilter_title": "Nachrichtenfilter", + "messageFilter_settingsSubtitle": "Spam und wiederholte Nachrichten ausblenden", + "messageFilter_enabled": "Nachrichten filtern", + "messageFilter_enabledSubtitle": "Gilt für Kanalnachrichten", + "messageFilter_displayTitle": "Gefilterte Nachrichten", + "messageFilter_displayPlaceholder": "Kleinen Platzhalter anzeigen", + "messageFilter_displayHide": "Komplett ausblenden", + "messageFilter_displayHideHelp": "Ausgeblendete Nachrichten bleiben in der Liste „Gefilterte Nachrichten“.", + "messageFilter_rulesSection": "Ihre Regeln", + "messageFilter_rulesEmpty": "Noch keine Regeln. Fügen Sie ein Wort, eine Wortgruppe oder einen Absendernamen hinzu, um passende Nachrichten auszublenden.", + "messageFilter_addRule": "Regel hinzufügen", + "messageFilter_editRule": "Regel bearbeiten", + "messageFilter_rulePattern": "Wort, Wortgruppe oder Name", + "messageFilter_rulePatternHint": "z. B. meshos", + "messageFilter_ruleWhere": "Suchen in", + "messageFilter_ruleFieldText": "Nachrichtentext", + "messageFilter_ruleFieldSender": "Absendername", + "messageFilter_ruleFieldBoth": "Beides", + "messageFilter_ruleMatch": "Übereinstimmung", + "messageFilter_ruleMatchContains": "Enthält", + "messageFilter_ruleMatchWholeWord": "Ganzes Wort", + "messageFilter_ruleMatchExact": "Genau", + "messageFilter_ruleDeleted": "Regel gelöscht", + "messageFilter_ruleSaved": "Regel gespeichert", + "messageFilter_automaticSection": "Automatisch", + "messageFilter_duplicates": "Wiederholte Nachrichten", + "messageFilter_duplicatesSubtitle": "Dieselbe Nachricht erneut gesendet oder von mehreren Absendern", + "messageFilter_repeatedCharacters": "Wiederholte Zeichen", + "messageFilter_repeatedCharactersSubtitle": "Nachrichten wie „aaaaaaaa“ oder „!!!!!!!!“", + "messageFilter_learning": "Aus Spam-Markierungen lernen", + "messageFilter_learningSubtitle": "{spam} Spam- und {notSpam} Kein-Spam-Beispiele", + "messageFilter_resetLearning": "Gelerntes zurücksetzen", + "messageFilter_resetLearningConfirm": "Alles vergessen, was aus Ihren Markierungen „Spam“ und „Kein Spam“ gelernt wurde? Ihre Regeln bleiben erhalten.", + "messageFilter_filteredMessages": "Gefilterte Nachrichten ({count})", + "messageFilter_filteredMessagesEmpty": "Es wurde nichts gefiltert.", + "messageFilter_ghostSingle": "Ausgeblendete Nachricht · Zum Anzeigen tippen", + "messageFilter_ghostMany": "{count, plural, one{{count} ausgeblendete Nachricht · Zum Anzeigen tippen} other{{count} ausgeblendete Nachrichten · Zum Anzeigen tippen}}", + "messageFilter_ghostSingleExpanded": "Ausgeblendete Nachricht wird angezeigt · Zum Ausblenden tippen", + "messageFilter_ghostManyExpanded": "{count, plural, =1{1 ausgeblendete Nachricht wird angezeigt · Zum Ausblenden tippen} other{{count} ausgeblendete Nachrichten werden angezeigt · Zum Ausblenden tippen}}", + "messageFilter_reasonTextRule": "Gefiltert: passt zu „{pattern}“", + "messageFilter_reasonSenderRule": "Gefiltert: Absender „{pattern}“", + "messageFilter_reasonRepeatedCharacters": "Gefiltert: wiederholte Zeichen", + "messageFilter_reasonDuplicate": "Gefiltert: wiederholte Nachricht", + "messageFilter_reasonCrossSenderDuplicate": "Gefiltert: dieselbe Nachricht von mehreren Absendern", + "messageFilter_reasonLearned": "Gefiltert: ähnelt Nachrichten, die Sie als Spam markiert haben", + "messageFilter_reasonManual": "Gefiltert: Sie haben dies als Spam markiert", + "messageFilter_notSpam": "Kein Spam", + "messageFilter_hideAgain": "Verbergen", + "messageFilter_markSpam": "Als Spam markieren", + "messageFilter_markedSpam": "Als Spam markiert", + "messageFilter_markedNotSpam": "Als Kein Spam markiert", + "messageFilter_filterSender": "Diesen Absender filtern", + "messageFilter_filterSenderConfirm": "Alle Nachrichten von „{name}“ ausblenden?", + "messageFilter_filterLikeThis": "Ähnliche Nachrichten filtern…", + "messageFilter_channelToggle": "Nachrichten in diesem Kanal filtern", + "messageFilter_ghostIconTooltip": "Von Ihrem Nachrichtenfilter ausgeblendet" } diff --git a/lib/l10n/app_en.arb b/lib/l10n/app_en.arb index 9e163d3e..066c62ff 100644 --- a/lib/l10n/app_en.arb +++ b/lib/l10n/app_en.arb @@ -3752,5 +3752,267 @@ "holidayGreeting_newYear": "Happy New Year|Happy New Year's", "@holidayGreeting_newYear": { "description": "Holiday greeting that plays the New Year's fireworks animation when it appears in a chat message. Matched in every app language and ignoring case and punctuation, so translate it as people actually write the greeting. Separate alternative phrasings with |." + }, + "messageFilter_title": "Message filter", + "@messageFilter_title": { + "description": "Message filter: Message filter" + }, + "messageFilter_settingsSubtitle": "Hide spam and repeated messages", + "@messageFilter_settingsSubtitle": { + "description": "Message filter: Hide spam and repeated messages" + }, + "messageFilter_enabled": "Filter messages", + "@messageFilter_enabled": { + "description": "Message filter: Filter messages" + }, + "messageFilter_enabledSubtitle": "Applies to channel messages", + "@messageFilter_enabledSubtitle": { + "description": "Message filter: Applies to channel messages" + }, + "messageFilter_displayTitle": "Filtered messages", + "@messageFilter_displayTitle": { + "description": "Message filter: Filtered messages" + }, + "messageFilter_displayPlaceholder": "Show a small placeholder", + "@messageFilter_displayPlaceholder": { + "description": "Message filter: Show a small placeholder" + }, + "messageFilter_displayHide": "Hide completely", + "@messageFilter_displayHide": { + "description": "Message filter: Hide completely" + }, + "messageFilter_displayHideHelp": "Hidden messages stay in the Filtered messages list.", + "@messageFilter_displayHideHelp": { + "description": "Message filter: Hidden messages stay in the Filtered messages list." + }, + "messageFilter_rulesSection": "Your rules", + "@messageFilter_rulesSection": { + "description": "Message filter: Your rules" + }, + "messageFilter_rulesEmpty": "No rules yet. Add a word, phrase or sender name to hide messages that match it.", + "@messageFilter_rulesEmpty": { + "description": "Message filter: No rules yet. Add a word, phrase or sender name to hide messages that match it." + }, + "messageFilter_addRule": "Add rule", + "@messageFilter_addRule": { + "description": "Message filter: Add rule" + }, + "messageFilter_editRule": "Edit rule", + "@messageFilter_editRule": { + "description": "Message filter: Edit rule" + }, + "messageFilter_rulePattern": "Word, phrase or name", + "@messageFilter_rulePattern": { + "description": "Message filter: Word, phrase or name" + }, + "messageFilter_rulePatternHint": "e.g. meshos", + "@messageFilter_rulePatternHint": { + "description": "Message filter: e.g. meshos" + }, + "messageFilter_ruleWhere": "Look in", + "@messageFilter_ruleWhere": { + "description": "Message filter: Look in" + }, + "messageFilter_ruleFieldText": "Message text", + "@messageFilter_ruleFieldText": { + "description": "Message filter: Message text" + }, + "messageFilter_ruleFieldSender": "Sender name", + "@messageFilter_ruleFieldSender": { + "description": "Message filter: Sender name" + }, + "messageFilter_ruleFieldBoth": "Both", + "@messageFilter_ruleFieldBoth": { + "description": "Message filter: Both" + }, + "messageFilter_ruleMatch": "Match", + "@messageFilter_ruleMatch": { + "description": "Message filter: Match" + }, + "messageFilter_ruleMatchContains": "Contains", + "@messageFilter_ruleMatchContains": { + "description": "Message filter: Contains" + }, + "messageFilter_ruleMatchWholeWord": "Whole word", + "@messageFilter_ruleMatchWholeWord": { + "description": "Message filter: Whole word" + }, + "messageFilter_ruleMatchExact": "Exact", + "@messageFilter_ruleMatchExact": { + "description": "Message filter: Exact" + }, + "messageFilter_ruleDeleted": "Rule deleted", + "@messageFilter_ruleDeleted": { + "description": "Message filter: Rule deleted" + }, + "messageFilter_ruleSaved": "Rule saved", + "@messageFilter_ruleSaved": { + "description": "Message filter: Rule saved" + }, + "messageFilter_automaticSection": "Automatic", + "@messageFilter_automaticSection": { + "description": "Message filter: Automatic" + }, + "messageFilter_duplicates": "Repeated messages", + "@messageFilter_duplicates": { + "description": "Message filter: Repeated messages" + }, + "messageFilter_duplicatesSubtitle": "The same message sent again, or by several senders", + "@messageFilter_duplicatesSubtitle": { + "description": "Message filter: The same message sent again, or by several senders" + }, + "messageFilter_repeatedCharacters": "Repeated characters", + "@messageFilter_repeatedCharacters": { + "description": "Message filter: Repeated characters" + }, + "messageFilter_repeatedCharactersSubtitle": "Messages like \"aaaaaaaa\" or \"!!!!!!!!\"", + "@messageFilter_repeatedCharactersSubtitle": { + "description": "Message filter: Messages like \"aaaaaaaa\" or \"!!!!!!!!\"" + }, + "messageFilter_learning": "Learn from Spam taps", + "@messageFilter_learning": { + "description": "Message filter: Learn from Spam taps" + }, + "messageFilter_learningSubtitle": "{spam} spam and {notSpam} not-spam examples", + "@messageFilter_learningSubtitle": { + "description": "Message filter: {spam} spam and {notSpam} not-spam examples", + "placeholders": { + "spam": { + "type": "int" + }, + "notSpam": { + "type": "int" + } + } + }, + "messageFilter_resetLearning": "Reset learning", + "@messageFilter_resetLearning": { + "description": "Message filter: Reset learning" + }, + "messageFilter_resetLearningConfirm": "Forget everything learned from your Spam and Not spam taps? Your rules are kept.", + "@messageFilter_resetLearningConfirm": { + "description": "Message filter: Forget everything learned from your Spam and Not spam taps? Your rules are kept." + }, + "messageFilter_filteredMessages": "Filtered messages ({count})", + "@messageFilter_filteredMessages": { + "description": "Message filter: Filtered messages ({count})", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_filteredMessagesEmpty": "Nothing has been filtered.", + "@messageFilter_filteredMessagesEmpty": { + "description": "Message filter: Nothing has been filtered." + }, + "messageFilter_ghostSingle": "Hidden message · Tap to view", + "@messageFilter_ghostSingle": { + "description": "Message filter: Hidden message · Tap to view" + }, + "messageFilter_ghostMany": "{count, plural, one{{count} hidden message · Tap to view} other{{count} hidden messages · Tap to view}}", + "@messageFilter_ghostMany": { + "description": "Message filter: {count, plural, one{{count} hidden message · Tap to view} other{{count} hidden messages · Tap to view}}", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_ghostSingleExpanded": "Showing hidden message · Tap to hide", + "@messageFilter_ghostSingleExpanded": { + "description": "Header above one revealed filtered message; tapping it hides the message again" + }, + "messageFilter_ghostManyExpanded": "{count, plural, =1{Showing 1 hidden message · Tap to hide} other{Showing {count} hidden messages · Tap to hide}}", + "@messageFilter_ghostManyExpanded": { + "description": "Header above a revealed run of filtered messages; tapping it hides them again", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_reasonTextRule": "Filtered: matches \"{pattern}\"", + "@messageFilter_reasonTextRule": { + "description": "Message filter: Filtered: matches \"{pattern}\"", + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonSenderRule": "Filtered: sender \"{pattern}\"", + "@messageFilter_reasonSenderRule": { + "description": "Message filter: Filtered: sender \"{pattern}\"", + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonRepeatedCharacters": "Filtered: repeated characters", + "@messageFilter_reasonRepeatedCharacters": { + "description": "Message filter: Filtered: repeated characters" + }, + "messageFilter_reasonDuplicate": "Filtered: repeated message", + "@messageFilter_reasonDuplicate": { + "description": "Message filter: Filtered: repeated message" + }, + "messageFilter_reasonCrossSenderDuplicate": "Filtered: same message from several senders", + "@messageFilter_reasonCrossSenderDuplicate": { + "description": "Message filter: Filtered: same message from several senders" + }, + "messageFilter_reasonLearned": "Filtered: looks like messages you marked as spam", + "@messageFilter_reasonLearned": { + "description": "Message filter: Filtered: looks like messages you marked as spam" + }, + "messageFilter_reasonManual": "Filtered: you marked this as spam", + "@messageFilter_reasonManual": { + "description": "Message filter: Filtered: you marked this as spam" + }, + "messageFilter_notSpam": "Not spam", + "@messageFilter_notSpam": { + "description": "Message filter: Not spam" + }, + "messageFilter_hideAgain": "Hide", + "@messageFilter_hideAgain": { + "description": "Message filter: Hide" + }, + "messageFilter_markSpam": "Mark as spam", + "@messageFilter_markSpam": { + "description": "Message filter: Mark as spam" + }, + "messageFilter_markedSpam": "Marked as spam", + "@messageFilter_markedSpam": { + "description": "Message filter: Marked as spam" + }, + "messageFilter_markedNotSpam": "Marked as not spam", + "@messageFilter_markedNotSpam": { + "description": "Message filter: Marked as not spam" + }, + "messageFilter_filterSender": "Filter this sender", + "@messageFilter_filterSender": { + "description": "Message filter: Filter this sender" + }, + "messageFilter_filterSenderConfirm": "Hide all messages from \"{name}\"?", + "@messageFilter_filterSenderConfirm": { + "description": "Message filter: Hide all messages from \"{name}\"?", + "placeholders": { + "name": { + "type": "String" + } + } + }, + "messageFilter_filterLikeThis": "Filter messages like this…", + "@messageFilter_filterLikeThis": { + "description": "Message filter: Filter messages like this…" + }, + "messageFilter_channelToggle": "Filter messages in this channel", + "@messageFilter_channelToggle": { + "description": "Message filter: Filter messages in this channel" + }, + "messageFilter_ghostIconTooltip": "Hidden by your message filter", + "@messageFilter_ghostIconTooltip": { + "description": "Message filter: Hidden by your message filter" } } diff --git a/lib/l10n/app_es.arb b/lib/l10n/app_es.arb index 8738430a..3779a747 100644 --- a/lib/l10n/app_es.arb +++ b/lib/l10n/app_es.arb @@ -3660,5 +3660,116 @@ "themes_chatBackground": "Fondo del chat", "themes_chatBackgroundHelp": "Se muestra en los chats que no tienen fondo propio", "themes_chatBackgroundEverywhere": "Usar en todos los chats", - "themes_chatBackgroundEverywhereHelp": "También reemplaza los fondos de chats individuales" + "themes_chatBackgroundEverywhereHelp": "También reemplaza los fondos de chats individuales", + "appSettings_showOnlineLinks": "Mostrar conexiones del mapa en línea", + "appSettings_showOnlineLinksSubtitle": "Muestra líneas de conexión entre nodos del mapa en línea", + "map_showOnlineLinks": "Mostrar conexiones del mapa en línea", + "messageFilter_title": "Filtro de mensajes", + "messageFilter_settingsSubtitle": "Oculta mensajes de spam y repetidos", + "messageFilter_enabled": "Filtrar mensajes", + "messageFilter_enabledSubtitle": "Se aplica a los mensajes de canal", + "messageFilter_displayTitle": "Mensajes filtrados", + "messageFilter_displayPlaceholder": "Mostrar un aviso pequeño", + "messageFilter_displayHide": "Ocultar por completo", + "messageFilter_displayHideHelp": "Los mensajes ocultos permanecen en la lista de Mensajes filtrados.", + "messageFilter_rulesSection": "Tus reglas", + "messageFilter_rulesEmpty": "Aún no hay reglas. Añade una palabra, frase o nombre de remitente para ocultar los mensajes que coincidan.", + "messageFilter_addRule": "Añadir regla", + "messageFilter_editRule": "Editar regla", + "messageFilter_rulePattern": "Palabra, frase o nombre", + "messageFilter_rulePatternHint": "p. ej. meshos", + "messageFilter_ruleWhere": "Buscar en", + "messageFilter_ruleFieldText": "Texto del mensaje", + "messageFilter_ruleFieldSender": "Nombre del remitente", + "messageFilter_ruleFieldBoth": "Ambos", + "messageFilter_ruleMatch": "Coincidencia", + "messageFilter_ruleMatchContains": "Contiene", + "messageFilter_ruleMatchWholeWord": "Palabra completa", + "messageFilter_ruleMatchExact": "Exacta", + "messageFilter_ruleDeleted": "Regla eliminada", + "messageFilter_ruleSaved": "Regla guardada", + "messageFilter_automaticSection": "Automático", + "messageFilter_duplicates": "Mensajes repetidos", + "messageFilter_duplicatesSubtitle": "El mismo mensaje enviado de nuevo, o por varios remitentes", + "messageFilter_repeatedCharacters": "Caracteres repetidos", + "messageFilter_repeatedCharactersSubtitle": "Mensajes como \"aaaaaaaa\" o \"!!!!!!!!\"", + "messageFilter_learning": "Aprender de los toques en Spam", + "messageFilter_learningSubtitle": "{spam} ejemplos de spam y {notSpam} de no spam", + "@messageFilter_learningSubtitle": { + "placeholders": { + "spam": { + "type": "int" + }, + "notSpam": { + "type": "int" + } + } + }, + "messageFilter_resetLearning": "Restablecer aprendizaje", + "messageFilter_resetLearningConfirm": "¿Olvidar todo lo aprendido de tus toques en Spam y No es spam? Tus reglas se conservan.", + "messageFilter_filteredMessages": "Mensajes filtrados ({count})", + "@messageFilter_filteredMessages": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_filteredMessagesEmpty": "No se ha filtrado nada.", + "messageFilter_ghostSingle": "Mensaje oculto · Toca para ver", + "messageFilter_ghostMany": "{count, plural, one{{count} mensaje oculto · Toca para ver} other{{count} mensajes ocultos · Toca para ver}}", + "@messageFilter_ghostMany": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_ghostSingleExpanded": "Mostrando mensaje oculto · Toca para ocultar", + "messageFilter_ghostManyExpanded": "{count, plural, =1{Mostrando 1 mensaje oculto · Toca para ocultar} other{Mostrando {count} mensajes ocultos · Toca para ocultar}}", + "@messageFilter_ghostManyExpanded": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_reasonTextRule": "Filtrado: coincide con \"{pattern}\"", + "@messageFilter_reasonTextRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonSenderRule": "Filtrado: remitente \"{pattern}\"", + "@messageFilter_reasonSenderRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonRepeatedCharacters": "Filtrado: caracteres repetidos", + "messageFilter_reasonDuplicate": "Filtrado: mensaje repetido", + "messageFilter_reasonCrossSenderDuplicate": "Filtrado: el mismo mensaje de varios remitentes", + "messageFilter_reasonLearned": "Filtrado: se parece a mensajes que marcaste como spam", + "messageFilter_reasonManual": "Filtrado: lo marcaste como spam", + "messageFilter_notSpam": "No es spam", + "messageFilter_hideAgain": "Ocultar", + "messageFilter_markSpam": "Marcar como spam", + "messageFilter_markedSpam": "Marcado como spam", + "messageFilter_markedNotSpam": "Marcado como no spam", + "messageFilter_filterSender": "Filtrar este remitente", + "messageFilter_filterSenderConfirm": "¿Ocultar todos los mensajes de \"{name}\"?", + "@messageFilter_filterSenderConfirm": { + "placeholders": { + "name": { + "type": "String" + } + } + }, + "messageFilter_filterLikeThis": "Filtrar mensajes como este…", + "messageFilter_channelToggle": "Filtrar mensajes en este canal", + "messageFilter_ghostIconTooltip": "Oculto por tu filtro de mensajes" } diff --git a/lib/l10n/app_fr.arb b/lib/l10n/app_fr.arb index 6c8c0531..601d64e5 100644 --- a/lib/l10n/app_fr.arb +++ b/lib/l10n/app_fr.arb @@ -3660,5 +3660,64 @@ "themes_chatBackground": "Fond de discussion", "themes_chatBackgroundHelp": "Affiché dans les discussions qui n'ont pas leur propre fond", "themes_chatBackgroundEverywhere": "Utiliser dans toutes les discussions", - "themes_chatBackgroundEverywhereHelp": "Remplace aussi les fonds définis pour chaque discussion" + "themes_chatBackgroundEverywhereHelp": "Remplace aussi les fonds définis pour chaque discussion", + "appSettings_showOnlineLinks": "Afficher les connexions de la carte en ligne", + "appSettings_showOnlineLinksSubtitle": "Affiche les lignes de connexion entre les nœuds de la carte en ligne", + "map_showOnlineLinks": "Afficher les connexions de la carte en ligne", + "messageFilter_title": "Filtre de messages", + "messageFilter_settingsSubtitle": "Masquer les spams et les messages répétés", + "messageFilter_enabled": "Filtrer les messages", + "messageFilter_enabledSubtitle": "S'applique aux messages des canaux", + "messageFilter_displayTitle": "Messages filtrés", + "messageFilter_displayPlaceholder": "Afficher un petit message à la place", + "messageFilter_displayHide": "Masquer complètement", + "messageFilter_displayHideHelp": "Les messages masqués restent dans la liste des messages filtrés.", + "messageFilter_rulesSection": "Vos règles", + "messageFilter_rulesEmpty": "Aucune règle pour l'instant. Ajoutez un mot, une phrase ou un nom d'expéditeur pour masquer les messages correspondants.", + "messageFilter_addRule": "Ajouter une règle", + "messageFilter_editRule": "Modifier la règle", + "messageFilter_rulePattern": "Mot, phrase ou nom", + "messageFilter_rulePatternHint": "p. ex. meshos", + "messageFilter_ruleWhere": "Chercher dans", + "messageFilter_ruleFieldText": "Texte du message", + "messageFilter_ruleFieldSender": "Nom de l'expéditeur", + "messageFilter_ruleFieldBoth": "Les deux", + "messageFilter_ruleMatch": "Correspondance", + "messageFilter_ruleMatchContains": "Contient", + "messageFilter_ruleMatchWholeWord": "Mot entier", + "messageFilter_ruleMatchExact": "Exacte", + "messageFilter_ruleDeleted": "Règle supprimée", + "messageFilter_ruleSaved": "Règle enregistrée", + "messageFilter_automaticSection": "Automatique", + "messageFilter_duplicates": "Messages répétés", + "messageFilter_duplicatesSubtitle": "Le même message envoyé de nouveau, ou par plusieurs expéditeurs", + "messageFilter_repeatedCharacters": "Caractères répétés", + "messageFilter_repeatedCharactersSubtitle": "Messages comme « aaaaaaaa » ou « !!!!!!!! »", + "messageFilter_learning": "Apprendre des appuis sur Spam", + "messageFilter_learningSubtitle": "{spam} exemples de spam et {notSpam} de non-spam", + "messageFilter_resetLearning": "Réinitialiser l'apprentissage", + "messageFilter_resetLearningConfirm": "Oublier tout ce qui a été appris de vos appuis sur Spam et Pas un spam ? Vos règles sont conservées.", + "messageFilter_filteredMessages": "Messages filtrés ({count})", + "messageFilter_filteredMessagesEmpty": "Rien n'a été filtré.", + "messageFilter_ghostSingle": "Message masqué · Appuyez pour voir", + "messageFilter_ghostMany": "{count, plural, one{{count} message masqué · Appuyez pour voir} other{{count} messages masqués · Appuyez pour voir}}", + "messageFilter_ghostSingleExpanded": "Message masqué affiché · Appuyez pour masquer", + "messageFilter_ghostManyExpanded": "{count, plural, =1{1 message masqué affiché · Appuyez pour masquer} other{{count} messages masqués affichés · Appuyez pour masquer}}", + "messageFilter_reasonTextRule": "Filtré : correspond à « {pattern} »", + "messageFilter_reasonSenderRule": "Filtré : expéditeur « {pattern} »", + "messageFilter_reasonRepeatedCharacters": "Filtré : caractères répétés", + "messageFilter_reasonDuplicate": "Filtré : message répété", + "messageFilter_reasonCrossSenderDuplicate": "Filtré : même message de plusieurs expéditeurs", + "messageFilter_reasonLearned": "Filtré : ressemble aux messages que vous avez marqués comme spam", + "messageFilter_reasonManual": "Filtré : vous avez marqué ce message comme spam", + "messageFilter_notSpam": "Pas un spam", + "messageFilter_hideAgain": "Masquer", + "messageFilter_markSpam": "Marquer comme spam", + "messageFilter_markedSpam": "Marqué comme spam", + "messageFilter_markedNotSpam": "Marqué comme pas un spam", + "messageFilter_filterSender": "Filtrer cet expéditeur", + "messageFilter_filterSenderConfirm": "Masquer tous les messages de « {name} » ?", + "messageFilter_filterLikeThis": "Filtrer les messages comme celui-ci…", + "messageFilter_channelToggle": "Filtrer les messages de ce canal", + "messageFilter_ghostIconTooltip": "Masqué par votre filtre de messages" } diff --git a/lib/l10n/app_hu.arb b/lib/l10n/app_hu.arb index 441a6f3e..51219c38 100644 --- a/lib/l10n/app_hu.arb +++ b/lib/l10n/app_hu.arb @@ -3565,5 +3565,116 @@ "themes_chatBackground": "Csevegés háttere", "themes_chatBackgroundHelp": "Azokban a csevegésekben jelenik meg, amelyeknek nincs saját hátterük", "themes_chatBackgroundEverywhere": "Használat minden csevegésben", - "themes_chatBackgroundEverywhereHelp": "Az egyes csevegésekhez beállított hátteret is felülírja" + "themes_chatBackgroundEverywhereHelp": "Az egyes csevegésekhez beállított hátteret is felülírja", + "appSettings_showOnlineLinks": "Online térkép kapcsolatainak megjelenítése", + "appSettings_showOnlineLinksSubtitle": "A csomópontok közötti kapcsolatvonalak megjelenítése az online térképről", + "map_showOnlineLinks": "Online térkép kapcsolatainak megjelenítése", + "messageFilter_title": "Üzenetszűrő", + "messageFilter_settingsSubtitle": "Spam és ismétlődő üzenetek elrejtése", + "messageFilter_enabled": "Üzenetek szűrése", + "messageFilter_enabledSubtitle": "A csatornaüzenetekre vonatkozik", + "messageFilter_displayTitle": "Szűrt üzenetek", + "messageFilter_displayPlaceholder": "Kis helyőrző megjelenítése", + "messageFilter_displayHide": "Teljes elrejtés", + "messageFilter_displayHideHelp": "Az elrejtett üzenetek a Szűrt üzenetek listában megmaradnak.", + "messageFilter_rulesSection": "Az Ön szabályai", + "messageFilter_rulesEmpty": "Még nincs szabály. Adjon hozzá egy szót, kifejezést vagy feladónevet, hogy elrejtse a rá illő üzeneteket.", + "messageFilter_addRule": "Szabály hozzáadása", + "messageFilter_editRule": "Szabály szerkesztése", + "messageFilter_rulePattern": "Szó, kifejezés vagy név", + "messageFilter_rulePatternHint": "pl. meshos", + "messageFilter_ruleWhere": "Keresés ebben", + "messageFilter_ruleFieldText": "Üzenet szövege", + "messageFilter_ruleFieldSender": "Feladó neve", + "messageFilter_ruleFieldBoth": "Mindkettő", + "messageFilter_ruleMatch": "Egyezés", + "messageFilter_ruleMatchContains": "Tartalmazza", + "messageFilter_ruleMatchWholeWord": "Egész szó", + "messageFilter_ruleMatchExact": "Pontos", + "messageFilter_ruleDeleted": "Szabály törölve", + "messageFilter_ruleSaved": "Szabály mentve", + "messageFilter_automaticSection": "Automatikus", + "messageFilter_duplicates": "Ismétlődő üzenetek", + "messageFilter_duplicatesSubtitle": "Ugyanaz az üzenet újra elküldve, vagy több feladótól", + "messageFilter_repeatedCharacters": "Ismétlődő karakterek", + "messageFilter_repeatedCharactersSubtitle": "Olyan üzenetek, mint „aaaaaaaa” vagy „!!!!!!!!”", + "messageFilter_learning": "Tanulás a Spam gombokból", + "messageFilter_learningSubtitle": "{spam} spam és {notSpam} nem spam példa", + "@messageFilter_learningSubtitle": { + "placeholders": { + "spam": { + "type": "int" + }, + "notSpam": { + "type": "int" + } + } + }, + "messageFilter_resetLearning": "Tanulás visszaállítása", + "messageFilter_resetLearningConfirm": "Elfelejtse mindazt, amit a Spam és Nem spam gombokból tanult? A szabályai megmaradnak.", + "messageFilter_filteredMessages": "Szűrt üzenetek ({count})", + "@messageFilter_filteredMessages": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_filteredMessagesEmpty": "Semmi sincs kiszűrve.", + "messageFilter_ghostSingle": "Elrejtett üzenet · Koppintson a megtekintéshez", + "messageFilter_ghostMany": "{count, plural, one{{count} elrejtett üzenet · Koppintson a megtekintéshez} other{{count} elrejtett üzenet · Koppintson a megtekintéshez}}", + "@messageFilter_ghostMany": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_ghostSingleExpanded": "Elrejtett üzenet megjelenítve · Koppintson az elrejtéshez", + "messageFilter_ghostManyExpanded": "{count, plural, =1{1 elrejtett üzenet megjelenítve · Koppintson az elrejtéshez} other{{count} elrejtett üzenet megjelenítve · Koppintson az elrejtéshez}}", + "@messageFilter_ghostManyExpanded": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_reasonTextRule": "Kiszűrve: egyezik ezzel: „{pattern}”", + "@messageFilter_reasonTextRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonSenderRule": "Kiszűrve: feladó „{pattern}”", + "@messageFilter_reasonSenderRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonRepeatedCharacters": "Kiszűrve: ismétlődő karakterek", + "messageFilter_reasonDuplicate": "Kiszűrve: ismétlődő üzenet", + "messageFilter_reasonCrossSenderDuplicate": "Kiszűrve: ugyanaz az üzenet több feladótól", + "messageFilter_reasonLearned": "Kiszűrve: hasonlít az Ön által spamnek jelölt üzenetekhez", + "messageFilter_reasonManual": "Kiszűrve: Ön spamnek jelölte", + "messageFilter_notSpam": "Nem spam", + "messageFilter_hideAgain": "Elrejtés", + "messageFilter_markSpam": "Jelölés spamként", + "messageFilter_markedSpam": "Spamként megjelölve", + "messageFilter_markedNotSpam": "Nem spamként megjelölve", + "messageFilter_filterSender": "E feladó szűrése", + "messageFilter_filterSenderConfirm": "Elrejti a(z) „{name}” összes üzenetét?", + "@messageFilter_filterSenderConfirm": { + "placeholders": { + "name": { + "type": "String" + } + } + }, + "messageFilter_filterLikeThis": "Ehhez hasonló üzenetek szűrése…", + "messageFilter_channelToggle": "Üzenetek szűrése ezen a csatornán", + "messageFilter_ghostIconTooltip": "Az üzenetszűrő elrejtette" } diff --git a/lib/l10n/app_it.arb b/lib/l10n/app_it.arb index 111bedf6..21f355b2 100644 --- a/lib/l10n/app_it.arb +++ b/lib/l10n/app_it.arb @@ -3660,5 +3660,64 @@ "themes_chatBackground": "Sfondo della chat", "themes_chatBackgroundHelp": "Mostrato nelle chat che non hanno uno sfondo proprio", "themes_chatBackgroundEverywhere": "Usa in tutte le chat", - "themes_chatBackgroundEverywhereHelp": "Sostituisce anche gli sfondi impostati sulle singole chat" + "themes_chatBackgroundEverywhereHelp": "Sostituisce anche gli sfondi impostati sulle singole chat", + "appSettings_showOnlineLinks": "Mostra connessioni della mappa online", + "appSettings_showOnlineLinksSubtitle": "Mostra le linee di collegamento tra i nodi della mappa online", + "map_showOnlineLinks": "Mostra connessioni della mappa online", + "messageFilter_title": "Filtro messaggi", + "messageFilter_settingsSubtitle": "Nascondi spam e messaggi ripetuti", + "messageFilter_enabled": "Filtra i messaggi", + "messageFilter_enabledSubtitle": "Si applica ai messaggi dei canali", + "messageFilter_displayTitle": "Messaggi filtrati", + "messageFilter_displayPlaceholder": "Mostra un piccolo segnaposto", + "messageFilter_displayHide": "Nascondi completamente", + "messageFilter_displayHideHelp": "I messaggi nascosti restano nell'elenco dei messaggi filtrati.", + "messageFilter_rulesSection": "Le tue regole", + "messageFilter_rulesEmpty": "Ancora nessuna regola. Aggiungi una parola, una frase o il nome di un mittente per nascondere i messaggi corrispondenti.", + "messageFilter_addRule": "Aggiungi regola", + "messageFilter_editRule": "Modifica regola", + "messageFilter_rulePattern": "Parola, frase o nome", + "messageFilter_rulePatternHint": "es. meshos", + "messageFilter_ruleWhere": "Cerca in", + "messageFilter_ruleFieldText": "Testo del messaggio", + "messageFilter_ruleFieldSender": "Nome del mittente", + "messageFilter_ruleFieldBoth": "Entrambi", + "messageFilter_ruleMatch": "Corrispondenza", + "messageFilter_ruleMatchContains": "Contiene", + "messageFilter_ruleMatchWholeWord": "Parola intera", + "messageFilter_ruleMatchExact": "Esatta", + "messageFilter_ruleDeleted": "Regola eliminata", + "messageFilter_ruleSaved": "Regola salvata", + "messageFilter_automaticSection": "Automatico", + "messageFilter_duplicates": "Messaggi ripetuti", + "messageFilter_duplicatesSubtitle": "Lo stesso messaggio inviato di nuovo, o da più mittenti", + "messageFilter_repeatedCharacters": "Caratteri ripetuti", + "messageFilter_repeatedCharactersSubtitle": "Messaggi come «aaaaaaaa» o «!!!!!!!!»", + "messageFilter_learning": "Impara dai tocchi su Spam", + "messageFilter_learningSubtitle": "{spam} esempi di spam e {notSpam} di non spam", + "messageFilter_resetLearning": "Azzera apprendimento", + "messageFilter_resetLearningConfirm": "Dimenticare tutto ciò che è stato appreso dai tuoi tocchi su Spam e Non spam? Le tue regole vengono mantenute.", + "messageFilter_filteredMessages": "Messaggi filtrati ({count})", + "messageFilter_filteredMessagesEmpty": "Nessun messaggio è stato filtrato.", + "messageFilter_ghostSingle": "Messaggio nascosto · Tocca per vedere", + "messageFilter_ghostMany": "{count, plural, one{{count} messaggio nascosto · Tocca per vedere} other{{count} messaggi nascosti · Tocca per vedere}}", + "messageFilter_ghostSingleExpanded": "Messaggio nascosto visibile · Tocca per nascondere", + "messageFilter_ghostManyExpanded": "{count, plural, =1{1 messaggio nascosto visibile · Tocca per nascondere} other{{count} messaggi nascosti visibili · Tocca per nascondere}}", + "messageFilter_reasonTextRule": "Filtrato: corrisponde a «{pattern}»", + "messageFilter_reasonSenderRule": "Filtrato: mittente «{pattern}»", + "messageFilter_reasonRepeatedCharacters": "Filtrato: caratteri ripetuti", + "messageFilter_reasonDuplicate": "Filtrato: messaggio ripetuto", + "messageFilter_reasonCrossSenderDuplicate": "Filtrato: stesso messaggio da più mittenti", + "messageFilter_reasonLearned": "Filtrato: assomiglia ai messaggi che hai segnato come spam", + "messageFilter_reasonManual": "Filtrato: hai segnato questo messaggio come spam", + "messageFilter_notSpam": "Non spam", + "messageFilter_hideAgain": "Nascondi", + "messageFilter_markSpam": "Segna come spam", + "messageFilter_markedSpam": "Segnato come spam", + "messageFilter_markedNotSpam": "Segnato come non spam", + "messageFilter_filterSender": "Filtra questo mittente", + "messageFilter_filterSenderConfirm": "Nascondere tutti i messaggi di «{name}»?", + "messageFilter_filterLikeThis": "Filtra messaggi come questo…", + "messageFilter_channelToggle": "Filtra i messaggi in questo canale", + "messageFilter_ghostIconTooltip": "Nascosto dal tuo filtro messaggi" } diff --git a/lib/l10n/app_ja.arb b/lib/l10n/app_ja.arb index b45310db..2ae41ad0 100644 --- a/lib/l10n/app_ja.arb +++ b/lib/l10n/app_ja.arb @@ -3660,5 +3660,270 @@ "holidayGreeting_halloween": "ハッピーハロウィン|ハッピーハロウィーン|ハッピーハロウィン|ハピハロ|トリックオアトリート|Happy Halloween", "holidayGreeting_thanksgiving": "ハッピーサンクスギビング|ハッピー・サンクスギビング|感謝祭おめでとう|Happy Thanksgiving", "holidayGreeting_christmas": "メリークリスマス|メリー・クリスマス|メリクリ|Merry Christmas", - "holidayGreeting_newYear": "あけましておめでとう|明けましておめでとう|あけおめ|アケオメ|ハッピーニューイヤー|ハッピー・ニューイヤー|謹賀新年|Happy New Year" + "holidayGreeting_newYear": "あけましておめでとう|明けましておめでとう|あけおめ|アケオメ|ハッピーニューイヤー|ハッピー・ニューイヤー|謹賀新年|Happy New Year", + "appSettings_showOnlineLinks": "オンライン地図の接続を表示", + "appSettings_showOnlineLinksSubtitle": "オンライン地図にあるノード間の接続線を表示する", + "map_showOnlineLinks": "オンライン地図の接続を表示", + "messageFilter_title": "メッセージフィルター", + "@messageFilter_title": { + "description": "Message filter: Message filter" + }, + "messageFilter_settingsSubtitle": "スパムや繰り返しのメッセージを隠す", + "@messageFilter_settingsSubtitle": { + "description": "Message filter: Hide spam and repeated messages" + }, + "messageFilter_enabled": "メッセージをフィルターする", + "@messageFilter_enabled": { + "description": "Message filter: Filter messages" + }, + "messageFilter_enabledSubtitle": "チャンネルのメッセージに適用されます", + "@messageFilter_enabledSubtitle": { + "description": "Message filter: Applies to channel messages" + }, + "messageFilter_displayTitle": "フィルターされたメッセージ", + "@messageFilter_displayTitle": { + "description": "Message filter: Filtered messages" + }, + "messageFilter_displayPlaceholder": "小さな表示を残す", + "@messageFilter_displayPlaceholder": { + "description": "Message filter: Show a small placeholder" + }, + "messageFilter_displayHide": "完全に隠す", + "@messageFilter_displayHide": { + "description": "Message filter: Hide completely" + }, + "messageFilter_displayHideHelp": "隠したメッセージは「フィルターされたメッセージ」の一覧に残ります。", + "@messageFilter_displayHideHelp": { + "description": "Message filter: Hidden messages stay in the Filtered messages list." + }, + "messageFilter_rulesSection": "あなたのルール", + "@messageFilter_rulesSection": { + "description": "Message filter: Your rules" + }, + "messageFilter_rulesEmpty": "ルールはまだありません。単語、フレーズ、送信者名を追加すると、一致するメッセージを隠せます。", + "@messageFilter_rulesEmpty": { + "description": "Message filter: No rules yet. Add a word, phrase or sender name to hide messages that match it." + }, + "messageFilter_addRule": "ルールを追加", + "@messageFilter_addRule": { + "description": "Message filter: Add rule" + }, + "messageFilter_editRule": "ルールを編集", + "@messageFilter_editRule": { + "description": "Message filter: Edit rule" + }, + "messageFilter_rulePattern": "単語、フレーズ、名前", + "@messageFilter_rulePattern": { + "description": "Message filter: Word, phrase or name" + }, + "messageFilter_rulePatternHint": "例: meshos", + "@messageFilter_rulePatternHint": { + "description": "Message filter: e.g. meshos" + }, + "messageFilter_ruleWhere": "対象", + "@messageFilter_ruleWhere": { + "description": "Message filter: Look in" + }, + "messageFilter_ruleFieldText": "メッセージ本文", + "@messageFilter_ruleFieldText": { + "description": "Message filter: Message text" + }, + "messageFilter_ruleFieldSender": "送信者名", + "@messageFilter_ruleFieldSender": { + "description": "Message filter: Sender name" + }, + "messageFilter_ruleFieldBoth": "両方", + "@messageFilter_ruleFieldBoth": { + "description": "Message filter: Both" + }, + "messageFilter_ruleMatch": "一致の条件", + "@messageFilter_ruleMatch": { + "description": "Message filter: Match" + }, + "messageFilter_ruleMatchContains": "含む", + "@messageFilter_ruleMatchContains": { + "description": "Message filter: Contains" + }, + "messageFilter_ruleMatchWholeWord": "単語全体", + "@messageFilter_ruleMatchWholeWord": { + "description": "Message filter: Whole word" + }, + "messageFilter_ruleMatchExact": "完全一致", + "@messageFilter_ruleMatchExact": { + "description": "Message filter: Exact" + }, + "messageFilter_ruleDeleted": "ルールを削除しました", + "@messageFilter_ruleDeleted": { + "description": "Message filter: Rule deleted" + }, + "messageFilter_ruleSaved": "ルールを保存しました", + "@messageFilter_ruleSaved": { + "description": "Message filter: Rule saved" + }, + "messageFilter_automaticSection": "自動", + "@messageFilter_automaticSection": { + "description": "Message filter: Automatic" + }, + "messageFilter_duplicates": "繰り返しのメッセージ", + "@messageFilter_duplicates": { + "description": "Message filter: Repeated messages" + }, + "messageFilter_duplicatesSubtitle": "同じメッセージが再送されたり、複数の送信者から届いたりしたもの", + "@messageFilter_duplicatesSubtitle": { + "description": "Message filter: The same message sent again, or by several senders" + }, + "messageFilter_repeatedCharacters": "繰り返しの文字", + "@messageFilter_repeatedCharacters": { + "description": "Message filter: Repeated characters" + }, + "messageFilter_repeatedCharactersSubtitle": "「aaaaaaaa」や「!!!!!!!!」のようなメッセージ", + "@messageFilter_repeatedCharactersSubtitle": { + "description": "Message filter: Messages like \"aaaaaaaa\" or \"!!!!!!!!\"" + }, + "messageFilter_learning": "スパムのタップから学習", + "@messageFilter_learning": { + "description": "Message filter: Learn from Spam taps" + }, + "messageFilter_learningSubtitle": "スパム {spam} 件、スパムではない {notSpam} 件の例", + "@messageFilter_learningSubtitle": { + "description": "Message filter: {spam} spam and {notSpam} not-spam examples", + "placeholders": { + "spam": { + "type": "int" + }, + "notSpam": { + "type": "int" + } + } + }, + "messageFilter_resetLearning": "学習をリセット", + "@messageFilter_resetLearning": { + "description": "Message filter: Reset learning" + }, + "messageFilter_resetLearningConfirm": "「スパム」と「スパムではない」のタップから学習した内容をすべて忘れますか?ルールはそのまま残ります。", + "@messageFilter_resetLearningConfirm": { + "description": "Message filter: Forget everything learned from your Spam and Not spam taps? Your rules are kept." + }, + "messageFilter_filteredMessages": "フィルターされたメッセージ ({count})", + "@messageFilter_filteredMessages": { + "description": "Message filter: Filtered messages ({count})", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_filteredMessagesEmpty": "フィルターされたメッセージはありません。", + "@messageFilter_filteredMessagesEmpty": { + "description": "Message filter: Nothing has been filtered." + }, + "messageFilter_ghostSingle": "隠したメッセージ · タップで表示", + "@messageFilter_ghostSingle": { + "description": "Message filter: Hidden message · Tap to view" + }, + "messageFilter_ghostMany": "{count, plural, other{隠したメッセージ {count} 件 · タップで表示}}", + "@messageFilter_ghostMany": { + "description": "Message filter: {count, plural, one{{count} hidden message · Tap to view} other{{count} hidden messages · Tap to view}}", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_ghostSingleExpanded": "隠したメッセージを表示中 · タップで隠す", + "@messageFilter_ghostSingleExpanded": { + "description": "Header above one revealed filtered message; tapping it hides the message again" + }, + "messageFilter_ghostManyExpanded": "{count, plural, other{隠したメッセージ {count} 件を表示中 · タップで隠す}}", + "@messageFilter_ghostManyExpanded": { + "description": "Header above a revealed run of filtered messages; tapping it hides them again", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_reasonTextRule": "フィルター: 「{pattern}」に一致", + "@messageFilter_reasonTextRule": { + "description": "Message filter: Filtered: matches \"{pattern}\"", + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonSenderRule": "フィルター: 送信者「{pattern}」", + "@messageFilter_reasonSenderRule": { + "description": "Message filter: Filtered: sender \"{pattern}\"", + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonRepeatedCharacters": "フィルター: 繰り返しの文字", + "@messageFilter_reasonRepeatedCharacters": { + "description": "Message filter: Filtered: repeated characters" + }, + "messageFilter_reasonDuplicate": "フィルター: 繰り返しのメッセージ", + "@messageFilter_reasonDuplicate": { + "description": "Message filter: Filtered: repeated message" + }, + "messageFilter_reasonCrossSenderDuplicate": "フィルター: 複数の送信者から同じメッセージ", + "@messageFilter_reasonCrossSenderDuplicate": { + "description": "Message filter: Filtered: same message from several senders" + }, + "messageFilter_reasonLearned": "フィルター: スパムにしたメッセージに似ています", + "@messageFilter_reasonLearned": { + "description": "Message filter: Filtered: looks like messages you marked as spam" + }, + "messageFilter_reasonManual": "フィルター: あなたがスパムにしました", + "@messageFilter_reasonManual": { + "description": "Message filter: Filtered: you marked this as spam" + }, + "messageFilter_notSpam": "スパムではない", + "@messageFilter_notSpam": { + "description": "Message filter: Not spam" + }, + "messageFilter_hideAgain": "隠す", + "@messageFilter_hideAgain": { + "description": "Message filter: Hide" + }, + "messageFilter_markSpam": "スパムにする", + "@messageFilter_markSpam": { + "description": "Message filter: Mark as spam" + }, + "messageFilter_markedSpam": "スパムとしてマークしました", + "@messageFilter_markedSpam": { + "description": "Message filter: Marked as spam" + }, + "messageFilter_markedNotSpam": "スパムではないとマークしました", + "@messageFilter_markedNotSpam": { + "description": "Message filter: Marked as not spam" + }, + "messageFilter_filterSender": "この送信者をフィルター", + "@messageFilter_filterSender": { + "description": "Message filter: Filter this sender" + }, + "messageFilter_filterSenderConfirm": "「{name}」からのメッセージをすべて隠しますか?", + "@messageFilter_filterSenderConfirm": { + "description": "Message filter: Hide all messages from \"{name}\"?", + "placeholders": { + "name": { + "type": "String" + } + } + }, + "messageFilter_filterLikeThis": "このようなメッセージをフィルター…", + "@messageFilter_filterLikeThis": { + "description": "Message filter: Filter messages like this…" + }, + "messageFilter_channelToggle": "このチャンネルでメッセージをフィルター", + "@messageFilter_channelToggle": { + "description": "Message filter: Filter messages in this channel" + }, + "messageFilter_ghostIconTooltip": "メッセージフィルターで隠されました", + "@messageFilter_ghostIconTooltip": { + "description": "Message filter: Hidden by your message filter" + } } diff --git a/lib/l10n/app_ko.arb b/lib/l10n/app_ko.arb index c9a44d90..73dbb876 100644 --- a/lib/l10n/app_ko.arb +++ b/lib/l10n/app_ko.arb @@ -3660,5 +3660,270 @@ "holidayGreeting_halloween": "해피 할로윈|즐거운 할로윈|행복한 할로윈|할로윈 축하해|할로윈 잘 보내세요|트릭 오어 트릿|해피 할로윈데이", "holidayGreeting_thanksgiving": "해피 땡스기빙|즐거운 추수감사절|행복한 추수감사절|추수감사절 잘 보내세요|추수감사절 축하해요|해피 땡스기빙데이", "holidayGreeting_christmas": "메리 크리스마스|즐거운 성탄절|즐거운 크리스마스|행복한 성탄절|성탄 축하드립니다|메리 크리스마스 되세요|해피 크리스마스|메리 크리스마스 이브", - "holidayGreeting_newYear": "새해 복 많이 받으세요|새해 복 많이 받아|새해 복 많이 받으십시오|새해 복 많이 받아요|해피 뉴 이어|해피 뉴이어|즐거운 새해|행복한 새해" + "holidayGreeting_newYear": "새해 복 많이 받으세요|새해 복 많이 받아|새해 복 많이 받으십시오|새해 복 많이 받아요|해피 뉴 이어|해피 뉴이어|즐거운 새해|행복한 새해", + "appSettings_showOnlineLinks": "온라인 지도 연결선 표시", + "appSettings_showOnlineLinksSubtitle": "온라인 지도에 있는 노드 간 연결선을 표시", + "map_showOnlineLinks": "온라인 지도 연결선 표시", + "messageFilter_title": "메시지 필터", + "@messageFilter_title": { + "description": "Message filter: Message filter" + }, + "messageFilter_settingsSubtitle": "스팸과 반복된 메시지를 숨김", + "@messageFilter_settingsSubtitle": { + "description": "Message filter: Hide spam and repeated messages" + }, + "messageFilter_enabled": "메시지 필터링", + "@messageFilter_enabled": { + "description": "Message filter: Filter messages" + }, + "messageFilter_enabledSubtitle": "채널 메시지에 적용됩니다", + "@messageFilter_enabledSubtitle": { + "description": "Message filter: Applies to channel messages" + }, + "messageFilter_displayTitle": "필터링된 메시지", + "@messageFilter_displayTitle": { + "description": "Message filter: Filtered messages" + }, + "messageFilter_displayPlaceholder": "작은 안내 표시", + "@messageFilter_displayPlaceholder": { + "description": "Message filter: Show a small placeholder" + }, + "messageFilter_displayHide": "완전히 숨기기", + "@messageFilter_displayHide": { + "description": "Message filter: Hide completely" + }, + "messageFilter_displayHideHelp": "숨겨진 메시지는 필터링된 메시지 목록에 남아 있습니다.", + "@messageFilter_displayHideHelp": { + "description": "Message filter: Hidden messages stay in the Filtered messages list." + }, + "messageFilter_rulesSection": "내 규칙", + "@messageFilter_rulesSection": { + "description": "Message filter: Your rules" + }, + "messageFilter_rulesEmpty": "아직 규칙이 없습니다. 단어, 문구 또는 발신자 이름을 추가하면 일치하는 메시지를 숨깁니다.", + "@messageFilter_rulesEmpty": { + "description": "Message filter: No rules yet. Add a word, phrase or sender name to hide messages that match it." + }, + "messageFilter_addRule": "규칙 추가", + "@messageFilter_addRule": { + "description": "Message filter: Add rule" + }, + "messageFilter_editRule": "규칙 수정", + "@messageFilter_editRule": { + "description": "Message filter: Edit rule" + }, + "messageFilter_rulePattern": "단어, 문구 또는 이름", + "@messageFilter_rulePattern": { + "description": "Message filter: Word, phrase or name" + }, + "messageFilter_rulePatternHint": "예: meshos", + "@messageFilter_rulePatternHint": { + "description": "Message filter: e.g. meshos" + }, + "messageFilter_ruleWhere": "확인할 위치", + "@messageFilter_ruleWhere": { + "description": "Message filter: Look in" + }, + "messageFilter_ruleFieldText": "메시지 내용", + "@messageFilter_ruleFieldText": { + "description": "Message filter: Message text" + }, + "messageFilter_ruleFieldSender": "발신자 이름", + "@messageFilter_ruleFieldSender": { + "description": "Message filter: Sender name" + }, + "messageFilter_ruleFieldBoth": "둘 다", + "@messageFilter_ruleFieldBoth": { + "description": "Message filter: Both" + }, + "messageFilter_ruleMatch": "일치 방식", + "@messageFilter_ruleMatch": { + "description": "Message filter: Match" + }, + "messageFilter_ruleMatchContains": "포함", + "@messageFilter_ruleMatchContains": { + "description": "Message filter: Contains" + }, + "messageFilter_ruleMatchWholeWord": "단어 전체", + "@messageFilter_ruleMatchWholeWord": { + "description": "Message filter: Whole word" + }, + "messageFilter_ruleMatchExact": "정확히 일치", + "@messageFilter_ruleMatchExact": { + "description": "Message filter: Exact" + }, + "messageFilter_ruleDeleted": "규칙을 삭제했습니다", + "@messageFilter_ruleDeleted": { + "description": "Message filter: Rule deleted" + }, + "messageFilter_ruleSaved": "규칙을 저장했습니다", + "@messageFilter_ruleSaved": { + "description": "Message filter: Rule saved" + }, + "messageFilter_automaticSection": "자동", + "@messageFilter_automaticSection": { + "description": "Message filter: Automatic" + }, + "messageFilter_duplicates": "반복된 메시지", + "@messageFilter_duplicates": { + "description": "Message filter: Repeated messages" + }, + "messageFilter_duplicatesSubtitle": "같은 메시지를 다시 보냈거나 여러 발신자가 보낸 경우", + "@messageFilter_duplicatesSubtitle": { + "description": "Message filter: The same message sent again, or by several senders" + }, + "messageFilter_repeatedCharacters": "반복된 문자", + "@messageFilter_repeatedCharacters": { + "description": "Message filter: Repeated characters" + }, + "messageFilter_repeatedCharactersSubtitle": "\"aaaaaaaa\" 또는 \"!!!!!!!!\" 같은 메시지", + "@messageFilter_repeatedCharactersSubtitle": { + "description": "Message filter: Messages like \"aaaaaaaa\" or \"!!!!!!!!\"" + }, + "messageFilter_learning": "스팸 표시에서 학습", + "@messageFilter_learning": { + "description": "Message filter: Learn from Spam taps" + }, + "messageFilter_learningSubtitle": "스팸 {spam}개, 스팸 아님 {notSpam}개 예시", + "@messageFilter_learningSubtitle": { + "description": "Message filter: {spam} spam and {notSpam} not-spam examples", + "placeholders": { + "spam": { + "type": "int" + }, + "notSpam": { + "type": "int" + } + } + }, + "messageFilter_resetLearning": "학습 초기화", + "@messageFilter_resetLearning": { + "description": "Message filter: Reset learning" + }, + "messageFilter_resetLearningConfirm": "스팸 및 스팸 아님 표시로 학습한 내용을 모두 지울까요? 내 규칙은 그대로 유지됩니다.", + "@messageFilter_resetLearningConfirm": { + "description": "Message filter: Forget everything learned from your Spam and Not spam taps? Your rules are kept." + }, + "messageFilter_filteredMessages": "필터링된 메시지 ({count})", + "@messageFilter_filteredMessages": { + "description": "Message filter: Filtered messages ({count})", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_filteredMessagesEmpty": "필터링된 메시지가 없습니다.", + "@messageFilter_filteredMessagesEmpty": { + "description": "Message filter: Nothing has been filtered." + }, + "messageFilter_ghostSingle": "숨겨진 메시지 · 눌러서 보기", + "@messageFilter_ghostSingle": { + "description": "Message filter: Hidden message · Tap to view" + }, + "messageFilter_ghostMany": "{count, plural, other{숨겨진 메시지 {count}개 · 눌러서 보기}}", + "@messageFilter_ghostMany": { + "description": "Message filter: {count, plural, one{{count} hidden message · Tap to view} other{{count} hidden messages · Tap to view}}", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_ghostSingleExpanded": "숨겨진 메시지 표시 중 · 눌러서 숨기기", + "@messageFilter_ghostSingleExpanded": { + "description": "Header above one revealed filtered message; tapping it hides the message again" + }, + "messageFilter_ghostManyExpanded": "{count, plural, other{숨겨진 메시지 {count}개 표시 중 · 눌러서 숨기기}}", + "@messageFilter_ghostManyExpanded": { + "description": "Header above a revealed run of filtered messages; tapping it hides them again", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_reasonTextRule": "필터링됨: \"{pattern}\"와(과) 일치", + "@messageFilter_reasonTextRule": { + "description": "Message filter: Filtered: matches \"{pattern}\"", + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonSenderRule": "필터링됨: 발신자 \"{pattern}\"", + "@messageFilter_reasonSenderRule": { + "description": "Message filter: Filtered: sender \"{pattern}\"", + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonRepeatedCharacters": "필터링됨: 반복된 문자", + "@messageFilter_reasonRepeatedCharacters": { + "description": "Message filter: Filtered: repeated characters" + }, + "messageFilter_reasonDuplicate": "필터링됨: 반복된 메시지", + "@messageFilter_reasonDuplicate": { + "description": "Message filter: Filtered: repeated message" + }, + "messageFilter_reasonCrossSenderDuplicate": "필터링됨: 여러 발신자의 같은 메시지", + "@messageFilter_reasonCrossSenderDuplicate": { + "description": "Message filter: Filtered: same message from several senders" + }, + "messageFilter_reasonLearned": "필터링됨: 스팸으로 표시한 메시지와 비슷함", + "@messageFilter_reasonLearned": { + "description": "Message filter: Filtered: looks like messages you marked as spam" + }, + "messageFilter_reasonManual": "필터링됨: 스팸으로 표시함", + "@messageFilter_reasonManual": { + "description": "Message filter: Filtered: you marked this as spam" + }, + "messageFilter_notSpam": "스팸 아님", + "@messageFilter_notSpam": { + "description": "Message filter: Not spam" + }, + "messageFilter_hideAgain": "숨기기", + "@messageFilter_hideAgain": { + "description": "Message filter: Hide" + }, + "messageFilter_markSpam": "스팸으로 표시", + "@messageFilter_markSpam": { + "description": "Message filter: Mark as spam" + }, + "messageFilter_markedSpam": "스팸으로 표시했습니다", + "@messageFilter_markedSpam": { + "description": "Message filter: Marked as spam" + }, + "messageFilter_markedNotSpam": "스팸 아님으로 표시했습니다", + "@messageFilter_markedNotSpam": { + "description": "Message filter: Marked as not spam" + }, + "messageFilter_filterSender": "이 발신자 필터링", + "@messageFilter_filterSender": { + "description": "Message filter: Filter this sender" + }, + "messageFilter_filterSenderConfirm": "\"{name}\"의 모든 메시지를 숨길까요?", + "@messageFilter_filterSenderConfirm": { + "description": "Message filter: Hide all messages from \"{name}\"?", + "placeholders": { + "name": { + "type": "String" + } + } + }, + "messageFilter_filterLikeThis": "이와 비슷한 메시지 필터링…", + "@messageFilter_filterLikeThis": { + "description": "Message filter: Filter messages like this…" + }, + "messageFilter_channelToggle": "이 채널에서 메시지 필터링", + "@messageFilter_channelToggle": { + "description": "Message filter: Filter messages in this channel" + }, + "messageFilter_ghostIconTooltip": "메시지 필터로 숨겨짐", + "@messageFilter_ghostIconTooltip": { + "description": "Message filter: Hidden by your message filter" + } } diff --git a/lib/l10n/app_localizations.dart b/lib/l10n/app_localizations.dart index 8908fd69..97e1a77e 100644 --- a/lib/l10n/app_localizations.dart +++ b/lib/l10n/app_localizations.dart @@ -11490,6 +11490,342 @@ abstract class AppLocalizations { /// In en, this message translates to: /// **'Happy New Year|Happy New Year\'s'** String get holidayGreeting_newYear; + + /// Message filter: Message filter + /// + /// In en, this message translates to: + /// **'Message filter'** + String get messageFilter_title; + + /// Message filter: Hide spam and repeated messages + /// + /// In en, this message translates to: + /// **'Hide spam and repeated messages'** + String get messageFilter_settingsSubtitle; + + /// Message filter: Filter messages + /// + /// In en, this message translates to: + /// **'Filter messages'** + String get messageFilter_enabled; + + /// Message filter: Applies to channel messages + /// + /// In en, this message translates to: + /// **'Applies to channel messages'** + String get messageFilter_enabledSubtitle; + + /// Message filter: Filtered messages + /// + /// In en, this message translates to: + /// **'Filtered messages'** + String get messageFilter_displayTitle; + + /// Message filter: Show a small placeholder + /// + /// In en, this message translates to: + /// **'Show a small placeholder'** + String get messageFilter_displayPlaceholder; + + /// Message filter: Hide completely + /// + /// In en, this message translates to: + /// **'Hide completely'** + String get messageFilter_displayHide; + + /// Message filter: Hidden messages stay in the Filtered messages list. + /// + /// In en, this message translates to: + /// **'Hidden messages stay in the Filtered messages list.'** + String get messageFilter_displayHideHelp; + + /// Message filter: Your rules + /// + /// In en, this message translates to: + /// **'Your rules'** + String get messageFilter_rulesSection; + + /// Message filter: No rules yet. Add a word, phrase or sender name to hide messages that match it. + /// + /// In en, this message translates to: + /// **'No rules yet. Add a word, phrase or sender name to hide messages that match it.'** + String get messageFilter_rulesEmpty; + + /// Message filter: Add rule + /// + /// In en, this message translates to: + /// **'Add rule'** + String get messageFilter_addRule; + + /// Message filter: Edit rule + /// + /// In en, this message translates to: + /// **'Edit rule'** + String get messageFilter_editRule; + + /// Message filter: Word, phrase or name + /// + /// In en, this message translates to: + /// **'Word, phrase or name'** + String get messageFilter_rulePattern; + + /// Message filter: e.g. meshos + /// + /// In en, this message translates to: + /// **'e.g. meshos'** + String get messageFilter_rulePatternHint; + + /// Message filter: Look in + /// + /// In en, this message translates to: + /// **'Look in'** + String get messageFilter_ruleWhere; + + /// Message filter: Message text + /// + /// In en, this message translates to: + /// **'Message text'** + String get messageFilter_ruleFieldText; + + /// Message filter: Sender name + /// + /// In en, this message translates to: + /// **'Sender name'** + String get messageFilter_ruleFieldSender; + + /// Message filter: Both + /// + /// In en, this message translates to: + /// **'Both'** + String get messageFilter_ruleFieldBoth; + + /// Message filter: Match + /// + /// In en, this message translates to: + /// **'Match'** + String get messageFilter_ruleMatch; + + /// Message filter: Contains + /// + /// In en, this message translates to: + /// **'Contains'** + String get messageFilter_ruleMatchContains; + + /// Message filter: Whole word + /// + /// In en, this message translates to: + /// **'Whole word'** + String get messageFilter_ruleMatchWholeWord; + + /// Message filter: Exact + /// + /// In en, this message translates to: + /// **'Exact'** + String get messageFilter_ruleMatchExact; + + /// Message filter: Rule deleted + /// + /// In en, this message translates to: + /// **'Rule deleted'** + String get messageFilter_ruleDeleted; + + /// Message filter: Rule saved + /// + /// In en, this message translates to: + /// **'Rule saved'** + String get messageFilter_ruleSaved; + + /// Message filter: Automatic + /// + /// In en, this message translates to: + /// **'Automatic'** + String get messageFilter_automaticSection; + + /// Message filter: Repeated messages + /// + /// In en, this message translates to: + /// **'Repeated messages'** + String get messageFilter_duplicates; + + /// Message filter: The same message sent again, or by several senders + /// + /// In en, this message translates to: + /// **'The same message sent again, or by several senders'** + String get messageFilter_duplicatesSubtitle; + + /// Message filter: Repeated characters + /// + /// In en, this message translates to: + /// **'Repeated characters'** + String get messageFilter_repeatedCharacters; + + /// Message filter: Messages like "aaaaaaaa" or "!!!!!!!!" + /// + /// In en, this message translates to: + /// **'Messages like \"aaaaaaaa\" or \"!!!!!!!!\"'** + String get messageFilter_repeatedCharactersSubtitle; + + /// Message filter: Learn from Spam taps + /// + /// In en, this message translates to: + /// **'Learn from Spam taps'** + String get messageFilter_learning; + + /// Message filter: {spam} spam and {notSpam} not-spam examples + /// + /// In en, this message translates to: + /// **'{spam} spam and {notSpam} not-spam examples'** + String messageFilter_learningSubtitle(int spam, int notSpam); + + /// Message filter: Reset learning + /// + /// In en, this message translates to: + /// **'Reset learning'** + String get messageFilter_resetLearning; + + /// Message filter: Forget everything learned from your Spam and Not spam taps? Your rules are kept. + /// + /// In en, this message translates to: + /// **'Forget everything learned from your Spam and Not spam taps? Your rules are kept.'** + String get messageFilter_resetLearningConfirm; + + /// Message filter: Filtered messages ({count}) + /// + /// In en, this message translates to: + /// **'Filtered messages ({count})'** + String messageFilter_filteredMessages(int count); + + /// Message filter: Nothing has been filtered. + /// + /// In en, this message translates to: + /// **'Nothing has been filtered.'** + String get messageFilter_filteredMessagesEmpty; + + /// Message filter: Hidden message · Tap to view + /// + /// In en, this message translates to: + /// **'Hidden message · Tap to view'** + String get messageFilter_ghostSingle; + + /// Message filter: {count, plural, one{{count} hidden message · Tap to view} other{{count} hidden messages · Tap to view}} + /// + /// In en, this message translates to: + /// **'{count, plural, one{{count} hidden message · Tap to view} other{{count} hidden messages · Tap to view}}'** + String messageFilter_ghostMany(int count); + + /// Header above one revealed filtered message; tapping it hides the message again + /// + /// In en, this message translates to: + /// **'Showing hidden message · Tap to hide'** + String get messageFilter_ghostSingleExpanded; + + /// Header above a revealed run of filtered messages; tapping it hides them again + /// + /// In en, this message translates to: + /// **'{count, plural, =1{Showing 1 hidden message · Tap to hide} other{Showing {count} hidden messages · Tap to hide}}'** + String messageFilter_ghostManyExpanded(int count); + + /// Message filter: Filtered: matches "{pattern}" + /// + /// In en, this message translates to: + /// **'Filtered: matches \"{pattern}\"'** + String messageFilter_reasonTextRule(String pattern); + + /// Message filter: Filtered: sender "{pattern}" + /// + /// In en, this message translates to: + /// **'Filtered: sender \"{pattern}\"'** + String messageFilter_reasonSenderRule(String pattern); + + /// Message filter: Filtered: repeated characters + /// + /// In en, this message translates to: + /// **'Filtered: repeated characters'** + String get messageFilter_reasonRepeatedCharacters; + + /// Message filter: Filtered: repeated message + /// + /// In en, this message translates to: + /// **'Filtered: repeated message'** + String get messageFilter_reasonDuplicate; + + /// Message filter: Filtered: same message from several senders + /// + /// In en, this message translates to: + /// **'Filtered: same message from several senders'** + String get messageFilter_reasonCrossSenderDuplicate; + + /// Message filter: Filtered: looks like messages you marked as spam + /// + /// In en, this message translates to: + /// **'Filtered: looks like messages you marked as spam'** + String get messageFilter_reasonLearned; + + /// Message filter: Filtered: you marked this as spam + /// + /// In en, this message translates to: + /// **'Filtered: you marked this as spam'** + String get messageFilter_reasonManual; + + /// Message filter: Not spam + /// + /// In en, this message translates to: + /// **'Not spam'** + String get messageFilter_notSpam; + + /// Message filter: Hide + /// + /// In en, this message translates to: + /// **'Hide'** + String get messageFilter_hideAgain; + + /// Message filter: Mark as spam + /// + /// In en, this message translates to: + /// **'Mark as spam'** + String get messageFilter_markSpam; + + /// Message filter: Marked as spam + /// + /// In en, this message translates to: + /// **'Marked as spam'** + String get messageFilter_markedSpam; + + /// Message filter: Marked as not spam + /// + /// In en, this message translates to: + /// **'Marked as not spam'** + String get messageFilter_markedNotSpam; + + /// Message filter: Filter this sender + /// + /// In en, this message translates to: + /// **'Filter this sender'** + String get messageFilter_filterSender; + + /// Message filter: Hide all messages from "{name}"? + /// + /// In en, this message translates to: + /// **'Hide all messages from \"{name}\"?'** + String messageFilter_filterSenderConfirm(String name); + + /// Message filter: Filter messages like this… + /// + /// In en, this message translates to: + /// **'Filter messages like this…'** + String get messageFilter_filterLikeThis; + + /// Message filter: Filter messages in this channel + /// + /// In en, this message translates to: + /// **'Filter messages in this channel'** + String get messageFilter_channelToggle; + + /// Message filter: Hidden by your message filter + /// + /// In en, this message translates to: + /// **'Hidden by your message filter'** + String get messageFilter_ghostIconTooltip; } class _AppLocalizationsDelegate diff --git a/lib/l10n/app_localizations_bg.dart b/lib/l10n/app_localizations_bg.dart index 4783f614..970957af 100644 --- a/lib/l10n/app_localizations_bg.dart +++ b/lib/l10n/app_localizations_bg.dart @@ -1421,11 +1421,12 @@ class AppLocalizationsBg extends AppLocalizations { 'Покажи други типове възли на картата'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => + 'Показвай връзките от онлайн картата'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Показва линии между възлите от онлайн картата'; @override String get appSettings_timeFilter => 'Филтриране по време'; @@ -2706,7 +2707,7 @@ class AppLocalizationsBg extends AppLocalizations { String get map_otherNodes => 'Други възли'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Показвай връзките от онлайн картата'; @override String get map_showOverlaps => 'Покриване на ключа на повтаряча'; @@ -6852,4 +6853,214 @@ class AppLocalizationsBg extends AppLocalizations { @override String get holidayGreeting_newYear => 'Честита Нова година|Щастлива Нова година|Happy New Year'; + + @override + String get messageFilter_title => 'Филтър за съобщения'; + + @override + String get messageFilter_settingsSubtitle => + 'Скрива спам и повтарящи се съобщения'; + + @override + String get messageFilter_enabled => 'Филтрирай съобщенията'; + + @override + String get messageFilter_enabledSubtitle => 'Важи за съобщенията в каналите'; + + @override + String get messageFilter_displayTitle => 'Филтрирани съобщения'; + + @override + String get messageFilter_displayPlaceholder => + 'Показвай малък знак на мястото им'; + + @override + String get messageFilter_displayHide => 'Скрий напълно'; + + @override + String get messageFilter_displayHideHelp => + 'Скритите съобщения остават в списъка „Филтрирани съобщения“.'; + + @override + String get messageFilter_rulesSection => 'Твоите правила'; + + @override + String get messageFilter_rulesEmpty => + 'Още няма правила. Добави дума, фраза или име на подател, за да скриваш съобщенията, които съвпадат.'; + + @override + String get messageFilter_addRule => 'Добави правило'; + + @override + String get messageFilter_editRule => 'Редактирай правило'; + + @override + String get messageFilter_rulePattern => 'Дума, фраза или име'; + + @override + String get messageFilter_rulePatternHint => 'напр. meshos'; + + @override + String get messageFilter_ruleWhere => 'Търси в'; + + @override + String get messageFilter_ruleFieldText => 'Текст на съобщението'; + + @override + String get messageFilter_ruleFieldSender => 'Име на подателя'; + + @override + String get messageFilter_ruleFieldBoth => 'И двете'; + + @override + String get messageFilter_ruleMatch => 'Съвпадение'; + + @override + String get messageFilter_ruleMatchContains => 'Съдържа'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Цяла дума'; + + @override + String get messageFilter_ruleMatchExact => 'Точно'; + + @override + String get messageFilter_ruleDeleted => 'Правилото е изтрито'; + + @override + String get messageFilter_ruleSaved => 'Правилото е запазено'; + + @override + String get messageFilter_automaticSection => 'Автоматично'; + + @override + String get messageFilter_duplicates => 'Повтарящи се съобщения'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Същото съобщение, изпратено отново или от няколко подателя'; + + @override + String get messageFilter_repeatedCharacters => 'Повтарящи се символи'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Съобщения като „aaaaaaaa“ или „!!!!!!!!“'; + + @override + String get messageFilter_learning => 'Учи се от натискането на „Спам“'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam примера за спам и $notSpam примера, които не са спам'; + } + + @override + String get messageFilter_resetLearning => 'Нулирай наученото'; + + @override + String get messageFilter_resetLearningConfirm => + 'Да се забрави ли всичко, научено от натискането на „Спам“ и „Не е спам“? Правилата ти се запазват.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Филтрирани съобщения ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'Нищо не е филтрирано.'; + + @override + String get messageFilter_ghostSingle => + 'Скрито съобщение · Докосни, за да го видиш'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count скрити съобщения · Докосни, за да ги видиш', + one: '$count скрито съобщение · Докосни, за да го видиш', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Показва се скрито съобщение · Докосни, за да го скриеш'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Показват се $count скрити съобщения · Докосни, за да ги скриеш', + one: 'Показва се 1 скрито съобщение · Докосни, за да го скриеш', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Филтрирано: съвпада с „$pattern“'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Филтрирано: подател „$pattern“'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Филтрирано: повтарящи се символи'; + + @override + String get messageFilter_reasonDuplicate => + 'Филтрирано: повтарящо се съобщение'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Филтрирано: същото съобщение от няколко подателя'; + + @override + String get messageFilter_reasonLearned => + 'Филтрирано: прилича на съобщения, които си отбелязал като спам'; + + @override + String get messageFilter_reasonManual => + 'Филтрирано: ти го отбеляза като спам'; + + @override + String get messageFilter_notSpam => 'Не е спам'; + + @override + String get messageFilter_hideAgain => 'Скрий'; + + @override + String get messageFilter_markSpam => 'Отбележи като спам'; + + @override + String get messageFilter_markedSpam => 'Отбелязано като спам'; + + @override + String get messageFilter_markedNotSpam => 'Отбелязано като не е спам'; + + @override + String get messageFilter_filterSender => 'Филтрирай този подател'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Да се скрият ли всички съобщения от „$name“?'; + } + + @override + String get messageFilter_filterLikeThis => 'Филтрирай съобщения като това…'; + + @override + String get messageFilter_channelToggle => + 'Филтрирай съобщенията в този канал'; + + @override + String get messageFilter_ghostIconTooltip => + 'Скрито от твоя филтър за съобщения'; } diff --git a/lib/l10n/app_localizations_de.dart b/lib/l10n/app_localizations_de.dart index 806c399b..40cf6888 100644 --- a/lib/l10n/app_localizations_de.dart +++ b/lib/l10n/app_localizations_de.dart @@ -1419,11 +1419,12 @@ class AppLocalizationsDe extends AppLocalizations { 'Andere Knotentypen auf der Karte anzeigen'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => + 'Verbindungen der Online-Karte anzeigen'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Verbindungslinien zwischen Knoten aus der Online-Karte anzeigen'; @override String get appSettings_timeFilter => 'Zeitfilter'; @@ -2705,7 +2706,7 @@ class AppLocalizationsDe extends AppLocalizations { String get map_otherNodes => 'Andere Knoten'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Verbindungen der Online-Karte anzeigen'; @override String get map_showOverlaps => 'Repeater-Schlüsselüberlappungen'; @@ -6864,4 +6865,215 @@ class AppLocalizationsDe extends AppLocalizations { @override String get holidayGreeting_newYear => 'Frohes neues Jahr|Gutes neues Jahr|Guten Rutsch|Prosit Neujahr|Happy New Year|Ein gutes neues Jahr|Guten Rutsch ins neue Jahr|Frohes Neues'; + + @override + String get messageFilter_title => 'Nachrichtenfilter'; + + @override + String get messageFilter_settingsSubtitle => + 'Spam und wiederholte Nachrichten ausblenden'; + + @override + String get messageFilter_enabled => 'Nachrichten filtern'; + + @override + String get messageFilter_enabledSubtitle => 'Gilt für Kanalnachrichten'; + + @override + String get messageFilter_displayTitle => 'Gefilterte Nachrichten'; + + @override + String get messageFilter_displayPlaceholder => 'Kleinen Platzhalter anzeigen'; + + @override + String get messageFilter_displayHide => 'Komplett ausblenden'; + + @override + String get messageFilter_displayHideHelp => + 'Ausgeblendete Nachrichten bleiben in der Liste „Gefilterte Nachrichten“.'; + + @override + String get messageFilter_rulesSection => 'Ihre Regeln'; + + @override + String get messageFilter_rulesEmpty => + 'Noch keine Regeln. Fügen Sie ein Wort, eine Wortgruppe oder einen Absendernamen hinzu, um passende Nachrichten auszublenden.'; + + @override + String get messageFilter_addRule => 'Regel hinzufügen'; + + @override + String get messageFilter_editRule => 'Regel bearbeiten'; + + @override + String get messageFilter_rulePattern => 'Wort, Wortgruppe oder Name'; + + @override + String get messageFilter_rulePatternHint => 'z. B. meshos'; + + @override + String get messageFilter_ruleWhere => 'Suchen in'; + + @override + String get messageFilter_ruleFieldText => 'Nachrichtentext'; + + @override + String get messageFilter_ruleFieldSender => 'Absendername'; + + @override + String get messageFilter_ruleFieldBoth => 'Beides'; + + @override + String get messageFilter_ruleMatch => 'Übereinstimmung'; + + @override + String get messageFilter_ruleMatchContains => 'Enthält'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Ganzes Wort'; + + @override + String get messageFilter_ruleMatchExact => 'Genau'; + + @override + String get messageFilter_ruleDeleted => 'Regel gelöscht'; + + @override + String get messageFilter_ruleSaved => 'Regel gespeichert'; + + @override + String get messageFilter_automaticSection => 'Automatisch'; + + @override + String get messageFilter_duplicates => 'Wiederholte Nachrichten'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Dieselbe Nachricht erneut gesendet oder von mehreren Absendern'; + + @override + String get messageFilter_repeatedCharacters => 'Wiederholte Zeichen'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Nachrichten wie „aaaaaaaa“ oder „!!!!!!!!“'; + + @override + String get messageFilter_learning => 'Aus Spam-Markierungen lernen'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam Spam- und $notSpam Kein-Spam-Beispiele'; + } + + @override + String get messageFilter_resetLearning => 'Gelerntes zurücksetzen'; + + @override + String get messageFilter_resetLearningConfirm => + 'Alles vergessen, was aus Ihren Markierungen „Spam“ und „Kein Spam“ gelernt wurde? Ihre Regeln bleiben erhalten.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Gefilterte Nachrichten ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => + 'Es wurde nichts gefiltert.'; + + @override + String get messageFilter_ghostSingle => + 'Ausgeblendete Nachricht · Zum Anzeigen tippen'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count ausgeblendete Nachrichten · Zum Anzeigen tippen', + one: '$count ausgeblendete Nachricht · Zum Anzeigen tippen', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Ausgeblendete Nachricht wird angezeigt · Zum Ausblenden tippen'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: + '$count ausgeblendete Nachrichten werden angezeigt · Zum Ausblenden tippen', + one: '1 ausgeblendete Nachricht wird angezeigt · Zum Ausblenden tippen', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Gefiltert: passt zu „$pattern“'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Gefiltert: Absender „$pattern“'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Gefiltert: wiederholte Zeichen'; + + @override + String get messageFilter_reasonDuplicate => + 'Gefiltert: wiederholte Nachricht'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Gefiltert: dieselbe Nachricht von mehreren Absendern'; + + @override + String get messageFilter_reasonLearned => + 'Gefiltert: ähnelt Nachrichten, die Sie als Spam markiert haben'; + + @override + String get messageFilter_reasonManual => + 'Gefiltert: Sie haben dies als Spam markiert'; + + @override + String get messageFilter_notSpam => 'Kein Spam'; + + @override + String get messageFilter_hideAgain => 'Verbergen'; + + @override + String get messageFilter_markSpam => 'Als Spam markieren'; + + @override + String get messageFilter_markedSpam => 'Als Spam markiert'; + + @override + String get messageFilter_markedNotSpam => 'Als Kein Spam markiert'; + + @override + String get messageFilter_filterSender => 'Diesen Absender filtern'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Alle Nachrichten von „$name“ ausblenden?'; + } + + @override + String get messageFilter_filterLikeThis => 'Ähnliche Nachrichten filtern…'; + + @override + String get messageFilter_channelToggle => + 'Nachrichten in diesem Kanal filtern'; + + @override + String get messageFilter_ghostIconTooltip => + 'Von Ihrem Nachrichtenfilter ausgeblendet'; } diff --git a/lib/l10n/app_localizations_en.dart b/lib/l10n/app_localizations_en.dart index c835670d..dd0320e4 100644 --- a/lib/l10n/app_localizations_en.dart +++ b/lib/l10n/app_localizations_en.dart @@ -6750,4 +6750,209 @@ class AppLocalizationsEn extends AppLocalizations { @override String get holidayGreeting_newYear => 'Happy New Year|Happy New Year\'s'; + + @override + String get messageFilter_title => 'Message filter'; + + @override + String get messageFilter_settingsSubtitle => + 'Hide spam and repeated messages'; + + @override + String get messageFilter_enabled => 'Filter messages'; + + @override + String get messageFilter_enabledSubtitle => 'Applies to channel messages'; + + @override + String get messageFilter_displayTitle => 'Filtered messages'; + + @override + String get messageFilter_displayPlaceholder => 'Show a small placeholder'; + + @override + String get messageFilter_displayHide => 'Hide completely'; + + @override + String get messageFilter_displayHideHelp => + 'Hidden messages stay in the Filtered messages list.'; + + @override + String get messageFilter_rulesSection => 'Your rules'; + + @override + String get messageFilter_rulesEmpty => + 'No rules yet. Add a word, phrase or sender name to hide messages that match it.'; + + @override + String get messageFilter_addRule => 'Add rule'; + + @override + String get messageFilter_editRule => 'Edit rule'; + + @override + String get messageFilter_rulePattern => 'Word, phrase or name'; + + @override + String get messageFilter_rulePatternHint => 'e.g. meshos'; + + @override + String get messageFilter_ruleWhere => 'Look in'; + + @override + String get messageFilter_ruleFieldText => 'Message text'; + + @override + String get messageFilter_ruleFieldSender => 'Sender name'; + + @override + String get messageFilter_ruleFieldBoth => 'Both'; + + @override + String get messageFilter_ruleMatch => 'Match'; + + @override + String get messageFilter_ruleMatchContains => 'Contains'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Whole word'; + + @override + String get messageFilter_ruleMatchExact => 'Exact'; + + @override + String get messageFilter_ruleDeleted => 'Rule deleted'; + + @override + String get messageFilter_ruleSaved => 'Rule saved'; + + @override + String get messageFilter_automaticSection => 'Automatic'; + + @override + String get messageFilter_duplicates => 'Repeated messages'; + + @override + String get messageFilter_duplicatesSubtitle => + 'The same message sent again, or by several senders'; + + @override + String get messageFilter_repeatedCharacters => 'Repeated characters'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Messages like \"aaaaaaaa\" or \"!!!!!!!!\"'; + + @override + String get messageFilter_learning => 'Learn from Spam taps'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam spam and $notSpam not-spam examples'; + } + + @override + String get messageFilter_resetLearning => 'Reset learning'; + + @override + String get messageFilter_resetLearningConfirm => + 'Forget everything learned from your Spam and Not spam taps? Your rules are kept.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Filtered messages ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => + 'Nothing has been filtered.'; + + @override + String get messageFilter_ghostSingle => 'Hidden message · Tap to view'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count hidden messages · Tap to view', + one: '$count hidden message · Tap to view', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Showing hidden message · Tap to hide'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Showing $count hidden messages · Tap to hide', + one: 'Showing 1 hidden message · Tap to hide', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Filtered: matches \"$pattern\"'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Filtered: sender \"$pattern\"'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Filtered: repeated characters'; + + @override + String get messageFilter_reasonDuplicate => 'Filtered: repeated message'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Filtered: same message from several senders'; + + @override + String get messageFilter_reasonLearned => + 'Filtered: looks like messages you marked as spam'; + + @override + String get messageFilter_reasonManual => 'Filtered: you marked this as spam'; + + @override + String get messageFilter_notSpam => 'Not spam'; + + @override + String get messageFilter_hideAgain => 'Hide'; + + @override + String get messageFilter_markSpam => 'Mark as spam'; + + @override + String get messageFilter_markedSpam => 'Marked as spam'; + + @override + String get messageFilter_markedNotSpam => 'Marked as not spam'; + + @override + String get messageFilter_filterSender => 'Filter this sender'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Hide all messages from \"$name\"?'; + } + + @override + String get messageFilter_filterLikeThis => 'Filter messages like this…'; + + @override + String get messageFilter_channelToggle => 'Filter messages in this channel'; + + @override + String get messageFilter_ghostIconTooltip => 'Hidden by your message filter'; } diff --git a/lib/l10n/app_localizations_es.dart b/lib/l10n/app_localizations_es.dart index 5b056b44..5761f84f 100644 --- a/lib/l10n/app_localizations_es.dart +++ b/lib/l10n/app_localizations_es.dart @@ -1410,11 +1410,12 @@ class AppLocalizationsEs extends AppLocalizations { 'Mostrar otros tipos de nodo en el mapa'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => + 'Mostrar conexiones del mapa en línea'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Muestra líneas de conexión entre nodos del mapa en línea'; @override String get appSettings_timeFilter => 'Filtro de tiempo'; @@ -2695,7 +2696,7 @@ class AppLocalizationsEs extends AppLocalizations { String get map_otherNodes => 'Otros nodos'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Mostrar conexiones del mapa en línea'; @override String get map_showOverlaps => 'Superposiciones de tecla repetidora'; @@ -6849,4 +6850,210 @@ class AppLocalizationsEs extends AppLocalizations { @override String get holidayGreeting_newYear => 'Feliz Año Nuevo|Próspero Año Nuevo|Feliz Año|Feliz Nochevieja|Próspero Año|Happy New Year'; + + @override + String get messageFilter_title => 'Filtro de mensajes'; + + @override + String get messageFilter_settingsSubtitle => + 'Oculta mensajes de spam y repetidos'; + + @override + String get messageFilter_enabled => 'Filtrar mensajes'; + + @override + String get messageFilter_enabledSubtitle => + 'Se aplica a los mensajes de canal'; + + @override + String get messageFilter_displayTitle => 'Mensajes filtrados'; + + @override + String get messageFilter_displayPlaceholder => 'Mostrar un aviso pequeño'; + + @override + String get messageFilter_displayHide => 'Ocultar por completo'; + + @override + String get messageFilter_displayHideHelp => + 'Los mensajes ocultos permanecen en la lista de Mensajes filtrados.'; + + @override + String get messageFilter_rulesSection => 'Tus reglas'; + + @override + String get messageFilter_rulesEmpty => + 'Aún no hay reglas. Añade una palabra, frase o nombre de remitente para ocultar los mensajes que coincidan.'; + + @override + String get messageFilter_addRule => 'Añadir regla'; + + @override + String get messageFilter_editRule => 'Editar regla'; + + @override + String get messageFilter_rulePattern => 'Palabra, frase o nombre'; + + @override + String get messageFilter_rulePatternHint => 'p. ej. meshos'; + + @override + String get messageFilter_ruleWhere => 'Buscar en'; + + @override + String get messageFilter_ruleFieldText => 'Texto del mensaje'; + + @override + String get messageFilter_ruleFieldSender => 'Nombre del remitente'; + + @override + String get messageFilter_ruleFieldBoth => 'Ambos'; + + @override + String get messageFilter_ruleMatch => 'Coincidencia'; + + @override + String get messageFilter_ruleMatchContains => 'Contiene'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Palabra completa'; + + @override + String get messageFilter_ruleMatchExact => 'Exacta'; + + @override + String get messageFilter_ruleDeleted => 'Regla eliminada'; + + @override + String get messageFilter_ruleSaved => 'Regla guardada'; + + @override + String get messageFilter_automaticSection => 'Automático'; + + @override + String get messageFilter_duplicates => 'Mensajes repetidos'; + + @override + String get messageFilter_duplicatesSubtitle => + 'El mismo mensaje enviado de nuevo, o por varios remitentes'; + + @override + String get messageFilter_repeatedCharacters => 'Caracteres repetidos'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Mensajes como \"aaaaaaaa\" o \"!!!!!!!!\"'; + + @override + String get messageFilter_learning => 'Aprender de los toques en Spam'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam ejemplos de spam y $notSpam de no spam'; + } + + @override + String get messageFilter_resetLearning => 'Restablecer aprendizaje'; + + @override + String get messageFilter_resetLearningConfirm => + '¿Olvidar todo lo aprendido de tus toques en Spam y No es spam? Tus reglas se conservan.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Mensajes filtrados ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'No se ha filtrado nada.'; + + @override + String get messageFilter_ghostSingle => 'Mensaje oculto · Toca para ver'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count mensajes ocultos · Toca para ver', + one: '$count mensaje oculto · Toca para ver', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Mostrando mensaje oculto · Toca para ocultar'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Mostrando $count mensajes ocultos · Toca para ocultar', + one: 'Mostrando 1 mensaje oculto · Toca para ocultar', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Filtrado: coincide con \"$pattern\"'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Filtrado: remitente \"$pattern\"'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Filtrado: caracteres repetidos'; + + @override + String get messageFilter_reasonDuplicate => 'Filtrado: mensaje repetido'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Filtrado: el mismo mensaje de varios remitentes'; + + @override + String get messageFilter_reasonLearned => + 'Filtrado: se parece a mensajes que marcaste como spam'; + + @override + String get messageFilter_reasonManual => 'Filtrado: lo marcaste como spam'; + + @override + String get messageFilter_notSpam => 'No es spam'; + + @override + String get messageFilter_hideAgain => 'Ocultar'; + + @override + String get messageFilter_markSpam => 'Marcar como spam'; + + @override + String get messageFilter_markedSpam => 'Marcado como spam'; + + @override + String get messageFilter_markedNotSpam => 'Marcado como no spam'; + + @override + String get messageFilter_filterSender => 'Filtrar este remitente'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return '¿Ocultar todos los mensajes de \"$name\"?'; + } + + @override + String get messageFilter_filterLikeThis => 'Filtrar mensajes como este…'; + + @override + String get messageFilter_channelToggle => 'Filtrar mensajes en este canal'; + + @override + String get messageFilter_ghostIconTooltip => + 'Oculto por tu filtro de mensajes'; } diff --git a/lib/l10n/app_localizations_fr.dart b/lib/l10n/app_localizations_fr.dart index 08b3758a..5609e5a4 100644 --- a/lib/l10n/app_localizations_fr.dart +++ b/lib/l10n/app_localizations_fr.dart @@ -1418,11 +1418,12 @@ class AppLocalizationsFr extends AppLocalizations { 'Afficher d\'autres types de nœuds sur la carte'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => + 'Afficher les connexions de la carte en ligne'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Affiche les lignes de connexion entre les nœuds de la carte en ligne'; @override String get appSettings_timeFilter => 'Filtre du temps'; @@ -2703,7 +2704,8 @@ class AppLocalizationsFr extends AppLocalizations { String get map_otherNodes => 'Autres nœuds'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => + 'Afficher les connexions de la carte en ligne'; @override String get map_showOverlaps => 'Chevauchements de clés de répéteur'; @@ -6873,4 +6875,213 @@ class AppLocalizationsFr extends AppLocalizations { @override String get holidayGreeting_newYear => 'Bonne année|Bonne et heureuse année|Happy New Year'; + + @override + String get messageFilter_title => 'Filtre de messages'; + + @override + String get messageFilter_settingsSubtitle => + 'Masquer les spams et les messages répétés'; + + @override + String get messageFilter_enabled => 'Filtrer les messages'; + + @override + String get messageFilter_enabledSubtitle => + 'S\'applique aux messages des canaux'; + + @override + String get messageFilter_displayTitle => 'Messages filtrés'; + + @override + String get messageFilter_displayPlaceholder => + 'Afficher un petit message à la place'; + + @override + String get messageFilter_displayHide => 'Masquer complètement'; + + @override + String get messageFilter_displayHideHelp => + 'Les messages masqués restent dans la liste des messages filtrés.'; + + @override + String get messageFilter_rulesSection => 'Vos règles'; + + @override + String get messageFilter_rulesEmpty => + 'Aucune règle pour l\'instant. Ajoutez un mot, une phrase ou un nom d\'expéditeur pour masquer les messages correspondants.'; + + @override + String get messageFilter_addRule => 'Ajouter une règle'; + + @override + String get messageFilter_editRule => 'Modifier la règle'; + + @override + String get messageFilter_rulePattern => 'Mot, phrase ou nom'; + + @override + String get messageFilter_rulePatternHint => 'p. ex. meshos'; + + @override + String get messageFilter_ruleWhere => 'Chercher dans'; + + @override + String get messageFilter_ruleFieldText => 'Texte du message'; + + @override + String get messageFilter_ruleFieldSender => 'Nom de l\'expéditeur'; + + @override + String get messageFilter_ruleFieldBoth => 'Les deux'; + + @override + String get messageFilter_ruleMatch => 'Correspondance'; + + @override + String get messageFilter_ruleMatchContains => 'Contient'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Mot entier'; + + @override + String get messageFilter_ruleMatchExact => 'Exacte'; + + @override + String get messageFilter_ruleDeleted => 'Règle supprimée'; + + @override + String get messageFilter_ruleSaved => 'Règle enregistrée'; + + @override + String get messageFilter_automaticSection => 'Automatique'; + + @override + String get messageFilter_duplicates => 'Messages répétés'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Le même message envoyé de nouveau, ou par plusieurs expéditeurs'; + + @override + String get messageFilter_repeatedCharacters => 'Caractères répétés'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Messages comme « aaaaaaaa » ou « !!!!!!!! »'; + + @override + String get messageFilter_learning => 'Apprendre des appuis sur Spam'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam exemples de spam et $notSpam de non-spam'; + } + + @override + String get messageFilter_resetLearning => 'Réinitialiser l\'apprentissage'; + + @override + String get messageFilter_resetLearningConfirm => + 'Oublier tout ce qui a été appris de vos appuis sur Spam et Pas un spam ? Vos règles sont conservées.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Messages filtrés ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'Rien n\'a été filtré.'; + + @override + String get messageFilter_ghostSingle => 'Message masqué · Appuyez pour voir'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count messages masqués · Appuyez pour voir', + one: '$count message masqué · Appuyez pour voir', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Message masqué affiché · Appuyez pour masquer'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count messages masqués affichés · Appuyez pour masquer', + one: '1 message masqué affiché · Appuyez pour masquer', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Filtré : correspond à « $pattern »'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Filtré : expéditeur « $pattern »'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Filtré : caractères répétés'; + + @override + String get messageFilter_reasonDuplicate => 'Filtré : message répété'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Filtré : même message de plusieurs expéditeurs'; + + @override + String get messageFilter_reasonLearned => + 'Filtré : ressemble aux messages que vous avez marqués comme spam'; + + @override + String get messageFilter_reasonManual => + 'Filtré : vous avez marqué ce message comme spam'; + + @override + String get messageFilter_notSpam => 'Pas un spam'; + + @override + String get messageFilter_hideAgain => 'Masquer'; + + @override + String get messageFilter_markSpam => 'Marquer comme spam'; + + @override + String get messageFilter_markedSpam => 'Marqué comme spam'; + + @override + String get messageFilter_markedNotSpam => 'Marqué comme pas un spam'; + + @override + String get messageFilter_filterSender => 'Filtrer cet expéditeur'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Masquer tous les messages de « $name » ?'; + } + + @override + String get messageFilter_filterLikeThis => + 'Filtrer les messages comme celui-ci…'; + + @override + String get messageFilter_channelToggle => 'Filtrer les messages de ce canal'; + + @override + String get messageFilter_ghostIconTooltip => + 'Masqué par votre filtre de messages'; } diff --git a/lib/l10n/app_localizations_hu.dart b/lib/l10n/app_localizations_hu.dart index 897866a4..b29c40b8 100644 --- a/lib/l10n/app_localizations_hu.dart +++ b/lib/l10n/app_localizations_hu.dart @@ -1408,11 +1408,12 @@ class AppLocalizationsHu extends AppLocalizations { 'Más csomóponttípusok megjelenítése a térképen'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => + 'Online térkép kapcsolatainak megjelenítése'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'A csomópontok közötti kapcsolatvonalak megjelenítése az online térképről'; @override String get appSettings_timeFilter => 'Időszűrő'; @@ -2693,7 +2694,8 @@ class AppLocalizationsHu extends AppLocalizations { String get map_otherNodes => 'Egyéb csomópontok'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => + 'Online térkép kapcsolatainak megjelenítése'; @override String get map_showOverlaps => 'Repeater Key átfedések'; @@ -6838,4 +6840,209 @@ class AppLocalizationsHu extends AppLocalizations { @override String get holidayGreeting_newYear => 'Boldog új évet|Boldog újévet|Boldog új esztendőt|BÚÉK|Happy New Year'; + + @override + String get messageFilter_title => 'Üzenetszűrő'; + + @override + String get messageFilter_settingsSubtitle => + 'Spam és ismétlődő üzenetek elrejtése'; + + @override + String get messageFilter_enabled => 'Üzenetek szűrése'; + + @override + String get messageFilter_enabledSubtitle => 'A csatornaüzenetekre vonatkozik'; + + @override + String get messageFilter_displayTitle => 'Szűrt üzenetek'; + + @override + String get messageFilter_displayPlaceholder => 'Kis helyőrző megjelenítése'; + + @override + String get messageFilter_displayHide => 'Teljes elrejtés'; + + @override + String get messageFilter_displayHideHelp => + 'Az elrejtett üzenetek a Szűrt üzenetek listában megmaradnak.'; + + @override + String get messageFilter_rulesSection => 'Az Ön szabályai'; + + @override + String get messageFilter_rulesEmpty => + 'Még nincs szabály. Adjon hozzá egy szót, kifejezést vagy feladónevet, hogy elrejtse a rá illő üzeneteket.'; + + @override + String get messageFilter_addRule => 'Szabály hozzáadása'; + + @override + String get messageFilter_editRule => 'Szabály szerkesztése'; + + @override + String get messageFilter_rulePattern => 'Szó, kifejezés vagy név'; + + @override + String get messageFilter_rulePatternHint => 'pl. meshos'; + + @override + String get messageFilter_ruleWhere => 'Keresés ebben'; + + @override + String get messageFilter_ruleFieldText => 'Üzenet szövege'; + + @override + String get messageFilter_ruleFieldSender => 'Feladó neve'; + + @override + String get messageFilter_ruleFieldBoth => 'Mindkettő'; + + @override + String get messageFilter_ruleMatch => 'Egyezés'; + + @override + String get messageFilter_ruleMatchContains => 'Tartalmazza'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Egész szó'; + + @override + String get messageFilter_ruleMatchExact => 'Pontos'; + + @override + String get messageFilter_ruleDeleted => 'Szabály törölve'; + + @override + String get messageFilter_ruleSaved => 'Szabály mentve'; + + @override + String get messageFilter_automaticSection => 'Automatikus'; + + @override + String get messageFilter_duplicates => 'Ismétlődő üzenetek'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Ugyanaz az üzenet újra elküldve, vagy több feladótól'; + + @override + String get messageFilter_repeatedCharacters => 'Ismétlődő karakterek'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Olyan üzenetek, mint „aaaaaaaa” vagy „!!!!!!!!”'; + + @override + String get messageFilter_learning => 'Tanulás a Spam gombokból'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam spam és $notSpam nem spam példa'; + } + + @override + String get messageFilter_resetLearning => 'Tanulás visszaállítása'; + + @override + String get messageFilter_resetLearningConfirm => + 'Elfelejtse mindazt, amit a Spam és Nem spam gombokból tanult? A szabályai megmaradnak.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Szűrt üzenetek ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'Semmi sincs kiszűrve.'; + + @override + String get messageFilter_ghostSingle => + 'Elrejtett üzenet · Koppintson a megtekintéshez'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count elrejtett üzenet · Koppintson a megtekintéshez', + one: '$count elrejtett üzenet · Koppintson a megtekintéshez', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Elrejtett üzenet megjelenítve · Koppintson az elrejtéshez'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count elrejtett üzenet megjelenítve · Koppintson az elrejtéshez', + one: '1 elrejtett üzenet megjelenítve · Koppintson az elrejtéshez', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Kiszűrve: egyezik ezzel: „$pattern”'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Kiszűrve: feladó „$pattern”'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Kiszűrve: ismétlődő karakterek'; + + @override + String get messageFilter_reasonDuplicate => 'Kiszűrve: ismétlődő üzenet'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Kiszűrve: ugyanaz az üzenet több feladótól'; + + @override + String get messageFilter_reasonLearned => + 'Kiszűrve: hasonlít az Ön által spamnek jelölt üzenetekhez'; + + @override + String get messageFilter_reasonManual => 'Kiszűrve: Ön spamnek jelölte'; + + @override + String get messageFilter_notSpam => 'Nem spam'; + + @override + String get messageFilter_hideAgain => 'Elrejtés'; + + @override + String get messageFilter_markSpam => 'Jelölés spamként'; + + @override + String get messageFilter_markedSpam => 'Spamként megjelölve'; + + @override + String get messageFilter_markedNotSpam => 'Nem spamként megjelölve'; + + @override + String get messageFilter_filterSender => 'E feladó szűrése'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Elrejti a(z) „$name” összes üzenetét?'; + } + + @override + String get messageFilter_filterLikeThis => 'Ehhez hasonló üzenetek szűrése…'; + + @override + String get messageFilter_channelToggle => 'Üzenetek szűrése ezen a csatornán'; + + @override + String get messageFilter_ghostIconTooltip => 'Az üzenetszűrő elrejtette'; } diff --git a/lib/l10n/app_localizations_it.dart b/lib/l10n/app_localizations_it.dart index 0b5a6208..16e1af46 100644 --- a/lib/l10n/app_localizations_it.dart +++ b/lib/l10n/app_localizations_it.dart @@ -1419,11 +1419,12 @@ class AppLocalizationsIt extends AppLocalizations { 'Mostra altri tipi di nodo sulla mappa'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => + 'Mostra connessioni della mappa online'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Mostra le linee di collegamento tra i nodi della mappa online'; @override String get appSettings_timeFilter => 'Filtro Temporale'; @@ -2704,7 +2705,7 @@ class AppLocalizationsIt extends AppLocalizations { String get map_otherNodes => 'Altri nodi'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Mostra connessioni della mappa online'; @override String get map_showOverlaps => 'Sovrapposizioni chiave ripetitore'; @@ -6859,4 +6860,214 @@ class AppLocalizationsIt extends AppLocalizations { @override String get holidayGreeting_newYear => 'Felice Anno Nuovo|Buon Anno Nuovo|Buon Capodanno|Buon Anno|Felice Anno|Felice Capodanno|Happy New Year'; + + @override + String get messageFilter_title => 'Filtro messaggi'; + + @override + String get messageFilter_settingsSubtitle => + 'Nascondi spam e messaggi ripetuti'; + + @override + String get messageFilter_enabled => 'Filtra i messaggi'; + + @override + String get messageFilter_enabledSubtitle => + 'Si applica ai messaggi dei canali'; + + @override + String get messageFilter_displayTitle => 'Messaggi filtrati'; + + @override + String get messageFilter_displayPlaceholder => 'Mostra un piccolo segnaposto'; + + @override + String get messageFilter_displayHide => 'Nascondi completamente'; + + @override + String get messageFilter_displayHideHelp => + 'I messaggi nascosti restano nell\'elenco dei messaggi filtrati.'; + + @override + String get messageFilter_rulesSection => 'Le tue regole'; + + @override + String get messageFilter_rulesEmpty => + 'Ancora nessuna regola. Aggiungi una parola, una frase o il nome di un mittente per nascondere i messaggi corrispondenti.'; + + @override + String get messageFilter_addRule => 'Aggiungi regola'; + + @override + String get messageFilter_editRule => 'Modifica regola'; + + @override + String get messageFilter_rulePattern => 'Parola, frase o nome'; + + @override + String get messageFilter_rulePatternHint => 'es. meshos'; + + @override + String get messageFilter_ruleWhere => 'Cerca in'; + + @override + String get messageFilter_ruleFieldText => 'Testo del messaggio'; + + @override + String get messageFilter_ruleFieldSender => 'Nome del mittente'; + + @override + String get messageFilter_ruleFieldBoth => 'Entrambi'; + + @override + String get messageFilter_ruleMatch => 'Corrispondenza'; + + @override + String get messageFilter_ruleMatchContains => 'Contiene'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Parola intera'; + + @override + String get messageFilter_ruleMatchExact => 'Esatta'; + + @override + String get messageFilter_ruleDeleted => 'Regola eliminata'; + + @override + String get messageFilter_ruleSaved => 'Regola salvata'; + + @override + String get messageFilter_automaticSection => 'Automatico'; + + @override + String get messageFilter_duplicates => 'Messaggi ripetuti'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Lo stesso messaggio inviato di nuovo, o da più mittenti'; + + @override + String get messageFilter_repeatedCharacters => 'Caratteri ripetuti'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Messaggi come «aaaaaaaa» o «!!!!!!!!»'; + + @override + String get messageFilter_learning => 'Impara dai tocchi su Spam'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam esempi di spam e $notSpam di non spam'; + } + + @override + String get messageFilter_resetLearning => 'Azzera apprendimento'; + + @override + String get messageFilter_resetLearningConfirm => + 'Dimenticare tutto ciò che è stato appreso dai tuoi tocchi su Spam e Non spam? Le tue regole vengono mantenute.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Messaggi filtrati ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => + 'Nessun messaggio è stato filtrato.'; + + @override + String get messageFilter_ghostSingle => + 'Messaggio nascosto · Tocca per vedere'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count messaggi nascosti · Tocca per vedere', + one: '$count messaggio nascosto · Tocca per vedere', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Messaggio nascosto visibile · Tocca per nascondere'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count messaggi nascosti visibili · Tocca per nascondere', + one: '1 messaggio nascosto visibile · Tocca per nascondere', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Filtrato: corrisponde a «$pattern»'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Filtrato: mittente «$pattern»'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Filtrato: caratteri ripetuti'; + + @override + String get messageFilter_reasonDuplicate => 'Filtrato: messaggio ripetuto'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Filtrato: stesso messaggio da più mittenti'; + + @override + String get messageFilter_reasonLearned => + 'Filtrato: assomiglia ai messaggi che hai segnato come spam'; + + @override + String get messageFilter_reasonManual => + 'Filtrato: hai segnato questo messaggio come spam'; + + @override + String get messageFilter_notSpam => 'Non spam'; + + @override + String get messageFilter_hideAgain => 'Nascondi'; + + @override + String get messageFilter_markSpam => 'Segna come spam'; + + @override + String get messageFilter_markedSpam => 'Segnato come spam'; + + @override + String get messageFilter_markedNotSpam => 'Segnato come non spam'; + + @override + String get messageFilter_filterSender => 'Filtra questo mittente'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Nascondere tutti i messaggi di «$name»?'; + } + + @override + String get messageFilter_filterLikeThis => 'Filtra messaggi come questo…'; + + @override + String get messageFilter_channelToggle => + 'Filtra i messaggi in questo canale'; + + @override + String get messageFilter_ghostIconTooltip => + 'Nascosto dal tuo filtro messaggi'; } diff --git a/lib/l10n/app_localizations_ja.dart b/lib/l10n/app_localizations_ja.dart index 8413e4b7..a04fe40d 100644 --- a/lib/l10n/app_localizations_ja.dart +++ b/lib/l10n/app_localizations_ja.dart @@ -1339,11 +1339,10 @@ class AppLocalizationsJa extends AppLocalizations { String get appSettings_showOtherNodesSubtitle => '地図上に、他のノードの種類を表示する'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => 'オンライン地図の接続を表示'; @override - String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + String get appSettings_showOnlineLinksSubtitle => 'オンライン地図にあるノード間の接続線を表示する'; @override String get appSettings_timeFilter => '時間フィルター'; @@ -2584,7 +2583,7 @@ class AppLocalizationsJa extends AppLocalizations { String get map_otherNodes => 'その他のノード'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'オンライン地図の接続を表示'; @override String get map_showOverlaps => 'リピータキーの重複'; @@ -6533,4 +6532,202 @@ class AppLocalizationsJa extends AppLocalizations { @override String get holidayGreeting_newYear => 'あけましておめでとう|明けましておめでとう|あけおめ|アケオメ|ハッピーニューイヤー|ハッピー・ニューイヤー|謹賀新年|Happy New Year'; + + @override + String get messageFilter_title => 'メッセージフィルター'; + + @override + String get messageFilter_settingsSubtitle => 'スパムや繰り返しのメッセージを隠す'; + + @override + String get messageFilter_enabled => 'メッセージをフィルターする'; + + @override + String get messageFilter_enabledSubtitle => 'チャンネルのメッセージに適用されます'; + + @override + String get messageFilter_displayTitle => 'フィルターされたメッセージ'; + + @override + String get messageFilter_displayPlaceholder => '小さな表示を残す'; + + @override + String get messageFilter_displayHide => '完全に隠す'; + + @override + String get messageFilter_displayHideHelp => + '隠したメッセージは「フィルターされたメッセージ」の一覧に残ります。'; + + @override + String get messageFilter_rulesSection => 'あなたのルール'; + + @override + String get messageFilter_rulesEmpty => + 'ルールはまだありません。単語、フレーズ、送信者名を追加すると、一致するメッセージを隠せます。'; + + @override + String get messageFilter_addRule => 'ルールを追加'; + + @override + String get messageFilter_editRule => 'ルールを編集'; + + @override + String get messageFilter_rulePattern => '単語、フレーズ、名前'; + + @override + String get messageFilter_rulePatternHint => '例: meshos'; + + @override + String get messageFilter_ruleWhere => '対象'; + + @override + String get messageFilter_ruleFieldText => 'メッセージ本文'; + + @override + String get messageFilter_ruleFieldSender => '送信者名'; + + @override + String get messageFilter_ruleFieldBoth => '両方'; + + @override + String get messageFilter_ruleMatch => '一致の条件'; + + @override + String get messageFilter_ruleMatchContains => '含む'; + + @override + String get messageFilter_ruleMatchWholeWord => '単語全体'; + + @override + String get messageFilter_ruleMatchExact => '完全一致'; + + @override + String get messageFilter_ruleDeleted => 'ルールを削除しました'; + + @override + String get messageFilter_ruleSaved => 'ルールを保存しました'; + + @override + String get messageFilter_automaticSection => '自動'; + + @override + String get messageFilter_duplicates => '繰り返しのメッセージ'; + + @override + String get messageFilter_duplicatesSubtitle => + '同じメッセージが再送されたり、複数の送信者から届いたりしたもの'; + + @override + String get messageFilter_repeatedCharacters => '繰り返しの文字'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + '「aaaaaaaa」や「!!!!!!!!」のようなメッセージ'; + + @override + String get messageFilter_learning => 'スパムのタップから学習'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return 'スパム $spam 件、スパムではない $notSpam 件の例'; + } + + @override + String get messageFilter_resetLearning => '学習をリセット'; + + @override + String get messageFilter_resetLearningConfirm => + '「スパム」と「スパムではない」のタップから学習した内容をすべて忘れますか?ルールはそのまま残ります。'; + + @override + String messageFilter_filteredMessages(int count) { + return 'フィルターされたメッセージ ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'フィルターされたメッセージはありません。'; + + @override + String get messageFilter_ghostSingle => '隠したメッセージ · タップで表示'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '隠したメッセージ $count 件 · タップで表示', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => '隠したメッセージを表示中 · タップで隠す'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '隠したメッセージ $count 件を表示中 · タップで隠す', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'フィルター: 「$pattern」に一致'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'フィルター: 送信者「$pattern」'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => 'フィルター: 繰り返しの文字'; + + @override + String get messageFilter_reasonDuplicate => 'フィルター: 繰り返しのメッセージ'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'フィルター: 複数の送信者から同じメッセージ'; + + @override + String get messageFilter_reasonLearned => 'フィルター: スパムにしたメッセージに似ています'; + + @override + String get messageFilter_reasonManual => 'フィルター: あなたがスパムにしました'; + + @override + String get messageFilter_notSpam => 'スパムではない'; + + @override + String get messageFilter_hideAgain => '隠す'; + + @override + String get messageFilter_markSpam => 'スパムにする'; + + @override + String get messageFilter_markedSpam => 'スパムとしてマークしました'; + + @override + String get messageFilter_markedNotSpam => 'スパムではないとマークしました'; + + @override + String get messageFilter_filterSender => 'この送信者をフィルター'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return '「$name」からのメッセージをすべて隠しますか?'; + } + + @override + String get messageFilter_filterLikeThis => 'このようなメッセージをフィルター…'; + + @override + String get messageFilter_channelToggle => 'このチャンネルでメッセージをフィルター'; + + @override + String get messageFilter_ghostIconTooltip => 'メッセージフィルターで隠されました'; } diff --git a/lib/l10n/app_localizations_ko.dart b/lib/l10n/app_localizations_ko.dart index 05994b3c..d6920fdb 100644 --- a/lib/l10n/app_localizations_ko.dart +++ b/lib/l10n/app_localizations_ko.dart @@ -1344,11 +1344,10 @@ class AppLocalizationsKo extends AppLocalizations { String get appSettings_showOtherNodesSubtitle => '지도에 다른 노드 유형을 표시'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => '온라인 지도 연결선 표시'; @override - String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + String get appSettings_showOnlineLinksSubtitle => '온라인 지도에 있는 노드 간 연결선을 표시'; @override String get appSettings_timeFilter => '시간 필터'; @@ -2588,7 +2587,7 @@ class AppLocalizationsKo extends AppLocalizations { String get map_otherNodes => '다른 노드'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => '온라인 지도 연결선 표시'; @override String get map_showOverlaps => '반복 키 중복'; @@ -6544,4 +6543,200 @@ class AppLocalizationsKo extends AppLocalizations { @override String get holidayGreeting_newYear => '새해 복 많이 받으세요|새해 복 많이 받아|새해 복 많이 받으십시오|새해 복 많이 받아요|해피 뉴 이어|해피 뉴이어|즐거운 새해|행복한 새해'; + + @override + String get messageFilter_title => '메시지 필터'; + + @override + String get messageFilter_settingsSubtitle => '스팸과 반복된 메시지를 숨김'; + + @override + String get messageFilter_enabled => '메시지 필터링'; + + @override + String get messageFilter_enabledSubtitle => '채널 메시지에 적용됩니다'; + + @override + String get messageFilter_displayTitle => '필터링된 메시지'; + + @override + String get messageFilter_displayPlaceholder => '작은 안내 표시'; + + @override + String get messageFilter_displayHide => '완전히 숨기기'; + + @override + String get messageFilter_displayHideHelp => '숨겨진 메시지는 필터링된 메시지 목록에 남아 있습니다.'; + + @override + String get messageFilter_rulesSection => '내 규칙'; + + @override + String get messageFilter_rulesEmpty => + '아직 규칙이 없습니다. 단어, 문구 또는 발신자 이름을 추가하면 일치하는 메시지를 숨깁니다.'; + + @override + String get messageFilter_addRule => '규칙 추가'; + + @override + String get messageFilter_editRule => '규칙 수정'; + + @override + String get messageFilter_rulePattern => '단어, 문구 또는 이름'; + + @override + String get messageFilter_rulePatternHint => '예: meshos'; + + @override + String get messageFilter_ruleWhere => '확인할 위치'; + + @override + String get messageFilter_ruleFieldText => '메시지 내용'; + + @override + String get messageFilter_ruleFieldSender => '발신자 이름'; + + @override + String get messageFilter_ruleFieldBoth => '둘 다'; + + @override + String get messageFilter_ruleMatch => '일치 방식'; + + @override + String get messageFilter_ruleMatchContains => '포함'; + + @override + String get messageFilter_ruleMatchWholeWord => '단어 전체'; + + @override + String get messageFilter_ruleMatchExact => '정확히 일치'; + + @override + String get messageFilter_ruleDeleted => '규칙을 삭제했습니다'; + + @override + String get messageFilter_ruleSaved => '규칙을 저장했습니다'; + + @override + String get messageFilter_automaticSection => '자동'; + + @override + String get messageFilter_duplicates => '반복된 메시지'; + + @override + String get messageFilter_duplicatesSubtitle => + '같은 메시지를 다시 보냈거나 여러 발신자가 보낸 경우'; + + @override + String get messageFilter_repeatedCharacters => '반복된 문자'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + '\"aaaaaaaa\" 또는 \"!!!!!!!!\" 같은 메시지'; + + @override + String get messageFilter_learning => '스팸 표시에서 학습'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '스팸 $spam개, 스팸 아님 $notSpam개 예시'; + } + + @override + String get messageFilter_resetLearning => '학습 초기화'; + + @override + String get messageFilter_resetLearningConfirm => + '스팸 및 스팸 아님 표시로 학습한 내용을 모두 지울까요? 내 규칙은 그대로 유지됩니다.'; + + @override + String messageFilter_filteredMessages(int count) { + return '필터링된 메시지 ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => '필터링된 메시지가 없습니다.'; + + @override + String get messageFilter_ghostSingle => '숨겨진 메시지 · 눌러서 보기'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '숨겨진 메시지 $count개 · 눌러서 보기', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => '숨겨진 메시지 표시 중 · 눌러서 숨기기'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '숨겨진 메시지 $count개 표시 중 · 눌러서 숨기기', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return '필터링됨: \"$pattern\"와(과) 일치'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return '필터링됨: 발신자 \"$pattern\"'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => '필터링됨: 반복된 문자'; + + @override + String get messageFilter_reasonDuplicate => '필터링됨: 반복된 메시지'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => '필터링됨: 여러 발신자의 같은 메시지'; + + @override + String get messageFilter_reasonLearned => '필터링됨: 스팸으로 표시한 메시지와 비슷함'; + + @override + String get messageFilter_reasonManual => '필터링됨: 스팸으로 표시함'; + + @override + String get messageFilter_notSpam => '스팸 아님'; + + @override + String get messageFilter_hideAgain => '숨기기'; + + @override + String get messageFilter_markSpam => '스팸으로 표시'; + + @override + String get messageFilter_markedSpam => '스팸으로 표시했습니다'; + + @override + String get messageFilter_markedNotSpam => '스팸 아님으로 표시했습니다'; + + @override + String get messageFilter_filterSender => '이 발신자 필터링'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return '\"$name\"의 모든 메시지를 숨길까요?'; + } + + @override + String get messageFilter_filterLikeThis => '이와 비슷한 메시지 필터링…'; + + @override + String get messageFilter_channelToggle => '이 채널에서 메시지 필터링'; + + @override + String get messageFilter_ghostIconTooltip => '메시지 필터로 숨겨짐'; } diff --git a/lib/l10n/app_localizations_nl.dart b/lib/l10n/app_localizations_nl.dart index 3be448a5..0699fab5 100644 --- a/lib/l10n/app_localizations_nl.dart +++ b/lib/l10n/app_localizations_nl.dart @@ -1409,11 +1409,12 @@ class AppLocalizationsNl extends AppLocalizations { 'Toon andere nodetypes op de kaart'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => + 'Verbindingen van de online kaart tonen'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Verbindingslijnen tussen nodes van de online kaart tonen'; @override String get appSettings_timeFilter => 'Filter op tijd'; @@ -2687,7 +2688,7 @@ class AppLocalizationsNl extends AppLocalizations { String get map_otherNodes => 'Andere Nodes'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Verbindingen van de online kaart tonen'; @override String get map_showOverlaps => 'Overlappende repeatersleutels'; @@ -6813,4 +6814,212 @@ class AppLocalizationsNl extends AppLocalizations { @override String get holidayGreeting_newYear => 'Gelukkig Nieuwjaar|Gelukkig nieuw jaar|Prettig nieuwjaar|Een gelukkig nieuwjaar|Happy New Year|Zalig nieuwjaar|Fijne jaarwisseling'; + + @override + String get messageFilter_title => 'Berichtenfilter'; + + @override + String get messageFilter_settingsSubtitle => + 'Spam en herhaalde berichten verbergen'; + + @override + String get messageFilter_enabled => 'Berichten filteren'; + + @override + String get messageFilter_enabledSubtitle => 'Geldt voor kanaalberichten'; + + @override + String get messageFilter_displayTitle => 'Gefilterde berichten'; + + @override + String get messageFilter_displayPlaceholder => + 'Een kleine plaatsaanduiding tonen'; + + @override + String get messageFilter_displayHide => 'Helemaal verbergen'; + + @override + String get messageFilter_displayHideHelp => + 'Verborgen berichten blijven in de lijst Gefilterde berichten staan.'; + + @override + String get messageFilter_rulesSection => 'Jouw regels'; + + @override + String get messageFilter_rulesEmpty => + 'Nog geen regels. Voeg een woord, zin of afzendernaam toe om passende berichten te verbergen.'; + + @override + String get messageFilter_addRule => 'Regel toevoegen'; + + @override + String get messageFilter_editRule => 'Regel bewerken'; + + @override + String get messageFilter_rulePattern => 'Woord, zin of naam'; + + @override + String get messageFilter_rulePatternHint => 'bijv. meshos'; + + @override + String get messageFilter_ruleWhere => 'Zoeken in'; + + @override + String get messageFilter_ruleFieldText => 'Berichttekst'; + + @override + String get messageFilter_ruleFieldSender => 'Afzendernaam'; + + @override + String get messageFilter_ruleFieldBoth => 'Beide'; + + @override + String get messageFilter_ruleMatch => 'Overeenkomst'; + + @override + String get messageFilter_ruleMatchContains => 'Bevat'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Heel woord'; + + @override + String get messageFilter_ruleMatchExact => 'Exact'; + + @override + String get messageFilter_ruleDeleted => 'Regel verwijderd'; + + @override + String get messageFilter_ruleSaved => 'Regel opgeslagen'; + + @override + String get messageFilter_automaticSection => 'Automatisch'; + + @override + String get messageFilter_duplicates => 'Herhaalde berichten'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Hetzelfde bericht opnieuw verstuurd, of door meerdere afzenders'; + + @override + String get messageFilter_repeatedCharacters => 'Herhaalde tekens'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Berichten zoals „aaaaaaaa” of „!!!!!!!!”'; + + @override + String get messageFilter_learning => 'Leren van Spam-tikken'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam spam- en $notSpam geen-spamvoorbeelden'; + } + + @override + String get messageFilter_resetLearning => 'Geleerde gegevens wissen'; + + @override + String get messageFilter_resetLearningConfirm => + 'Alles vergeten wat is geleerd van je tikken op Spam en Geen spam? Je regels blijven behouden.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Gefilterde berichten ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'Er is niets gefilterd.'; + + @override + String get messageFilter_ghostSingle => + 'Verborgen bericht · Tik om te bekijken'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count verborgen berichten · Tik om te bekijken', + one: '$count verborgen bericht · Tik om te bekijken', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Verborgen bericht wordt getoond · Tik om te verbergen'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count verborgen berichten worden getoond · Tik om te verbergen', + one: '1 verborgen bericht wordt getoond · Tik om te verbergen', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Gefilterd: komt overeen met „$pattern”'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Gefilterd: afzender „$pattern”'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Gefilterd: herhaalde tekens'; + + @override + String get messageFilter_reasonDuplicate => 'Gefilterd: herhaald bericht'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Gefilterd: hetzelfde bericht van meerdere afzenders'; + + @override + String get messageFilter_reasonLearned => + 'Gefilterd: lijkt op berichten die je als spam hebt gemarkeerd'; + + @override + String get messageFilter_reasonManual => + 'Gefilterd: je hebt dit als spam gemarkeerd'; + + @override + String get messageFilter_notSpam => 'Geen spam'; + + @override + String get messageFilter_hideAgain => 'Verbergen'; + + @override + String get messageFilter_markSpam => 'Markeren als spam'; + + @override + String get messageFilter_markedSpam => 'Gemarkeerd als spam'; + + @override + String get messageFilter_markedNotSpam => 'Gemarkeerd als geen spam'; + + @override + String get messageFilter_filterSender => 'Deze afzender filteren'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Alle berichten van „$name” verbergen?'; + } + + @override + String get messageFilter_filterLikeThis => 'Berichten zoals dit filteren…'; + + @override + String get messageFilter_channelToggle => 'Berichten in dit kanaal filteren'; + + @override + String get messageFilter_ghostIconTooltip => + 'Verborgen door je berichtenfilter'; } diff --git a/lib/l10n/app_localizations_pl.dart b/lib/l10n/app_localizations_pl.dart index e9eba38a..68bb1d23 100644 --- a/lib/l10n/app_localizations_pl.dart +++ b/lib/l10n/app_localizations_pl.dart @@ -1423,11 +1423,11 @@ class AppLocalizationsPl extends AppLocalizations { 'Wyświetl inne typy węzłów na mapie'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => 'Pokaż połączenia z mapy online'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Wyświetlaj linie połączeń między węzłami z mapy online'; @override String get appSettings_timeFilter => 'Filtrowanie Czasu'; @@ -2720,7 +2720,7 @@ class AppLocalizationsPl extends AppLocalizations { String get map_otherNodes => 'Inne węzły'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Pokaż połączenia z mapy online'; @override String get map_showOverlaps => 'Nakładające się klucze przekaźników'; @@ -6877,4 +6877,217 @@ class AppLocalizationsPl extends AppLocalizations { @override String get holidayGreeting_newYear => 'Szczęśliwego Nowego Roku|Dobrego Nowego Roku|Udanego Nowego Roku|Happy New Year'; + + @override + String get messageFilter_title => 'Filtr wiadomości'; + + @override + String get messageFilter_settingsSubtitle => + 'Ukrywaj spam i powtarzające się wiadomości'; + + @override + String get messageFilter_enabled => 'Filtruj wiadomości'; + + @override + String get messageFilter_enabledSubtitle => 'Dotyczy wiadomości na kanałach'; + + @override + String get messageFilter_displayTitle => 'Przefiltrowane wiadomości'; + + @override + String get messageFilter_displayPlaceholder => 'Pokaż mały znacznik'; + + @override + String get messageFilter_displayHide => 'Ukryj całkowicie'; + + @override + String get messageFilter_displayHideHelp => + 'Ukryte wiadomości pozostają na liście Przefiltrowanych wiadomości.'; + + @override + String get messageFilter_rulesSection => 'Twoje reguły'; + + @override + String get messageFilter_rulesEmpty => + 'Brak reguł. Dodaj słowo, wyrażenie lub nazwę nadawcy, aby ukrywać pasujące wiadomości.'; + + @override + String get messageFilter_addRule => 'Dodaj regułę'; + + @override + String get messageFilter_editRule => 'Edytuj regułę'; + + @override + String get messageFilter_rulePattern => 'Słowo, wyrażenie lub nazwa'; + + @override + String get messageFilter_rulePatternHint => 'np. meshos'; + + @override + String get messageFilter_ruleWhere => 'Szukaj w'; + + @override + String get messageFilter_ruleFieldText => 'Treść wiadomości'; + + @override + String get messageFilter_ruleFieldSender => 'Nazwa nadawcy'; + + @override + String get messageFilter_ruleFieldBoth => 'Oba'; + + @override + String get messageFilter_ruleMatch => 'Dopasowanie'; + + @override + String get messageFilter_ruleMatchContains => 'Zawiera'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Całe słowo'; + + @override + String get messageFilter_ruleMatchExact => 'Dokładne'; + + @override + String get messageFilter_ruleDeleted => 'Reguła usunięta'; + + @override + String get messageFilter_ruleSaved => 'Reguła zapisana'; + + @override + String get messageFilter_automaticSection => 'Automatyczne'; + + @override + String get messageFilter_duplicates => 'Powtarzające się wiadomości'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Ta sama wiadomość wysłana ponownie lub przez kilku nadawców'; + + @override + String get messageFilter_repeatedCharacters => 'Powtarzające się znaki'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Wiadomości typu „aaaaaaaa” lub „!!!!!!!!”'; + + @override + String get messageFilter_learning => 'Ucz się z oznaczeń Spam'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return 'Przykłady: $spam spam i $notSpam nie-spam'; + } + + @override + String get messageFilter_resetLearning => 'Zresetuj naukę'; + + @override + String get messageFilter_resetLearningConfirm => + 'Zapomnieć wszystko, czego nauczył się filtr z Twoich oznaczeń Spam i Nie spam? Twoje reguły zostaną zachowane.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Przefiltrowane wiadomości ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => + 'Nic nie zostało przefiltrowane.'; + + @override + String get messageFilter_ghostSingle => + 'Ukryta wiadomość · Dotknij, aby zobaczyć'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count ukrytej wiadomości · Dotknij, aby zobaczyć', + many: '$count ukrytych wiadomości · Dotknij, aby zobaczyć', + few: '$count ukryte wiadomości · Dotknij, aby zobaczyć', + one: '$count ukryta wiadomość · Dotknij, aby zobaczyć', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Pokazano ukrytą wiadomość · Dotknij, aby ukryć'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Pokazano $count ukrytej wiadomości · Dotknij, aby ukryć', + many: 'Pokazano $count ukrytych wiadomości · Dotknij, aby ukryć', + few: 'Pokazano $count ukryte wiadomości · Dotknij, aby ukryć', + one: 'Pokazano 1 ukrytą wiadomość · Dotknij, aby ukryć', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Przefiltrowano: pasuje do „$pattern”'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Przefiltrowano: nadawca „$pattern”'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Przefiltrowano: powtarzające się znaki'; + + @override + String get messageFilter_reasonDuplicate => + 'Przefiltrowano: powtórzona wiadomość'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Przefiltrowano: ta sama wiadomość od kilku nadawców'; + + @override + String get messageFilter_reasonLearned => + 'Przefiltrowano: podobna do wiadomości oznaczonych jako spam'; + + @override + String get messageFilter_reasonManual => + 'Przefiltrowano: oznaczyłeś to jako spam'; + + @override + String get messageFilter_notSpam => 'Nie spam'; + + @override + String get messageFilter_hideAgain => 'Ukryj'; + + @override + String get messageFilter_markSpam => 'Oznacz jako spam'; + + @override + String get messageFilter_markedSpam => 'Oznaczono jako spam'; + + @override + String get messageFilter_markedNotSpam => 'Oznaczono jako nie spam'; + + @override + String get messageFilter_filterSender => 'Filtruj tego nadawcę'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Ukryć wszystkie wiadomości od „$name”?'; + } + + @override + String get messageFilter_filterLikeThis => 'Filtruj podobne wiadomości…'; + + @override + String get messageFilter_channelToggle => 'Filtruj wiadomości na tym kanale'; + + @override + String get messageFilter_ghostIconTooltip => + 'Ukryte przez Twój filtr wiadomości'; } diff --git a/lib/l10n/app_localizations_pt.dart b/lib/l10n/app_localizations_pt.dart index b43c2aa6..e96b50a9 100644 --- a/lib/l10n/app_localizations_pt.dart +++ b/lib/l10n/app_localizations_pt.dart @@ -1413,11 +1413,11 @@ class AppLocalizationsPt extends AppLocalizations { 'Exibir outros tipos de nó no mapa'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => 'Mostrar conexões do mapa online'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Exibe linhas de conexão entre nós do mapa online'; @override String get appSettings_timeFilter => 'Filtro de Tempo'; @@ -2698,7 +2698,7 @@ class AppLocalizationsPt extends AppLocalizations { String get map_otherNodes => 'Outros Nós'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Mostrar conexões do mapa online'; @override String get map_showOverlaps => 'Sobreposições da Chave Repeater'; @@ -6843,4 +6843,209 @@ class AppLocalizationsPt extends AppLocalizations { @override String get holidayGreeting_newYear => 'Feliz Ano Novo|Próspero Ano Novo|Feliz Ano|Feliz Réveillon|Boas Festas e Feliz Ano Novo|Happy New Year'; + + @override + String get messageFilter_title => 'Filtro de mensagens'; + + @override + String get messageFilter_settingsSubtitle => + 'Oculta mensagens de spam e repetidas'; + + @override + String get messageFilter_enabled => 'Filtrar mensagens'; + + @override + String get messageFilter_enabledSubtitle => 'Aplica-se às mensagens de canal'; + + @override + String get messageFilter_displayTitle => 'Mensagens filtradas'; + + @override + String get messageFilter_displayPlaceholder => 'Mostrar um aviso pequeno'; + + @override + String get messageFilter_displayHide => 'Ocultar completamente'; + + @override + String get messageFilter_displayHideHelp => + 'As mensagens ocultas continuam na lista de Mensagens filtradas.'; + + @override + String get messageFilter_rulesSection => 'Suas regras'; + + @override + String get messageFilter_rulesEmpty => + 'Ainda não há regras. Adicione uma palavra, frase ou nome de remetente para ocultar as mensagens que correspondam.'; + + @override + String get messageFilter_addRule => 'Adicionar regra'; + + @override + String get messageFilter_editRule => 'Editar regra'; + + @override + String get messageFilter_rulePattern => 'Palavra, frase ou nome'; + + @override + String get messageFilter_rulePatternHint => 'ex.: meshos'; + + @override + String get messageFilter_ruleWhere => 'Procurar em'; + + @override + String get messageFilter_ruleFieldText => 'Texto da mensagem'; + + @override + String get messageFilter_ruleFieldSender => 'Nome do remetente'; + + @override + String get messageFilter_ruleFieldBoth => 'Ambos'; + + @override + String get messageFilter_ruleMatch => 'Correspondência'; + + @override + String get messageFilter_ruleMatchContains => 'Contém'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Palavra inteira'; + + @override + String get messageFilter_ruleMatchExact => 'Exata'; + + @override + String get messageFilter_ruleDeleted => 'Regra excluída'; + + @override + String get messageFilter_ruleSaved => 'Regra salva'; + + @override + String get messageFilter_automaticSection => 'Automático'; + + @override + String get messageFilter_duplicates => 'Mensagens repetidas'; + + @override + String get messageFilter_duplicatesSubtitle => + 'A mesma mensagem enviada de novo, ou por vários remetentes'; + + @override + String get messageFilter_repeatedCharacters => 'Caracteres repetidos'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Mensagens como \"aaaaaaaa\" ou \"!!!!!!!!\"'; + + @override + String get messageFilter_learning => 'Aprender com os toques em Spam'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam exemplos de spam e $notSpam de não spam'; + } + + @override + String get messageFilter_resetLearning => 'Redefinir aprendizado'; + + @override + String get messageFilter_resetLearningConfirm => + 'Esquecer tudo o que foi aprendido com seus toques em Spam e Não é spam? Suas regras são mantidas.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Mensagens filtradas ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'Nada foi filtrado.'; + + @override + String get messageFilter_ghostSingle => 'Mensagem oculta · Toque para ver'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count mensagens ocultas · Toque para ver', + one: '$count mensagem oculta · Toque para ver', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Mostrando mensagem oculta · Toque para ocultar'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Mostrando $count mensagens ocultas · Toque para ocultar', + one: 'Mostrando 1 mensagem oculta · Toque para ocultar', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Filtrada: corresponde a \"$pattern\"'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Filtrada: remetente \"$pattern\"'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Filtrada: caracteres repetidos'; + + @override + String get messageFilter_reasonDuplicate => 'Filtrada: mensagem repetida'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Filtrada: a mesma mensagem de vários remetentes'; + + @override + String get messageFilter_reasonLearned => + 'Filtrada: parece mensagens que você marcou como spam'; + + @override + String get messageFilter_reasonManual => 'Filtrada: você a marcou como spam'; + + @override + String get messageFilter_notSpam => 'Não é spam'; + + @override + String get messageFilter_hideAgain => 'Ocultar'; + + @override + String get messageFilter_markSpam => 'Marcar como spam'; + + @override + String get messageFilter_markedSpam => 'Marcada como spam'; + + @override + String get messageFilter_markedNotSpam => 'Marcada como não spam'; + + @override + String get messageFilter_filterSender => 'Filtrar este remetente'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Ocultar todas as mensagens de \"$name\"?'; + } + + @override + String get messageFilter_filterLikeThis => 'Filtrar mensagens como esta…'; + + @override + String get messageFilter_channelToggle => 'Filtrar mensagens neste canal'; + + @override + String get messageFilter_ghostIconTooltip => + 'Oculta pelo seu filtro de mensagens'; } diff --git a/lib/l10n/app_localizations_ru.dart b/lib/l10n/app_localizations_ru.dart index 5922d05c..3c551464 100644 --- a/lib/l10n/app_localizations_ru.dart +++ b/lib/l10n/app_localizations_ru.dart @@ -1419,11 +1419,11 @@ class AppLocalizationsRu extends AppLocalizations { 'Отображать другие типы нод на карте'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => 'Показывать связи с онлайн-карты'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Показывать линии связи между узлами с онлайн-карты'; @override String get appSettings_timeFilter => 'Фильтр по времени'; @@ -2704,7 +2704,7 @@ class AppLocalizationsRu extends AppLocalizations { String get map_otherNodes => 'Другие ноды'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Показывать связи с онлайн-карты'; @override String get map_showOverlaps => 'Перекрытия ключа повтора'; @@ -6863,4 +6863,219 @@ class AppLocalizationsRu extends AppLocalizations { @override String get holidayGreeting_newYear => 'С Новым годом|С Новым годом!|С Новым годом всех|С наступающим Новым годом|Счастливого Нового года|Happy New Year'; + + @override + String get messageFilter_title => 'Фильтр сообщений'; + + @override + String get messageFilter_settingsSubtitle => + 'Скрывать спам и повторяющиеся сообщения'; + + @override + String get messageFilter_enabled => 'Фильтровать сообщения'; + + @override + String get messageFilter_enabledSubtitle => + 'Действует для сообщений в каналах'; + + @override + String get messageFilter_displayTitle => 'Отфильтрованные сообщения'; + + @override + String get messageFilter_displayPlaceholder => + 'Показывать небольшую заглушку'; + + @override + String get messageFilter_displayHide => 'Скрывать полностью'; + + @override + String get messageFilter_displayHideHelp => + 'Скрытые сообщения остаются в списке «Отфильтрованные сообщения».'; + + @override + String get messageFilter_rulesSection => 'Ваши правила'; + + @override + String get messageFilter_rulesEmpty => + 'Правил пока нет. Добавьте слово, фразу или имя отправителя, чтобы скрывать подходящие сообщения.'; + + @override + String get messageFilter_addRule => 'Добавить правило'; + + @override + String get messageFilter_editRule => 'Изменить правило'; + + @override + String get messageFilter_rulePattern => 'Слово, фраза или имя'; + + @override + String get messageFilter_rulePatternHint => 'например, meshos'; + + @override + String get messageFilter_ruleWhere => 'Где искать'; + + @override + String get messageFilter_ruleFieldText => 'Текст сообщения'; + + @override + String get messageFilter_ruleFieldSender => 'Имя отправителя'; + + @override + String get messageFilter_ruleFieldBoth => 'И то и другое'; + + @override + String get messageFilter_ruleMatch => 'Совпадение'; + + @override + String get messageFilter_ruleMatchContains => 'Содержит'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Целое слово'; + + @override + String get messageFilter_ruleMatchExact => 'Точное'; + + @override + String get messageFilter_ruleDeleted => 'Правило удалено'; + + @override + String get messageFilter_ruleSaved => 'Правило сохранено'; + + @override + String get messageFilter_automaticSection => 'Автоматически'; + + @override + String get messageFilter_duplicates => 'Повторяющиеся сообщения'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Одно и то же сообщение, отправленное снова или несколькими отправителями'; + + @override + String get messageFilter_repeatedCharacters => 'Повторяющиеся символы'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Сообщения вроде «aaaaaaaa» или «!!!!!!!!»'; + + @override + String get messageFilter_learning => 'Учиться на нажатиях «Спам»'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return 'Примеров спама: $spam, не спама: $notSpam'; + } + + @override + String get messageFilter_resetLearning => 'Сбросить обучение'; + + @override + String get messageFilter_resetLearningConfirm => + 'Забыть всё, чему фильтр научился на ваших нажатиях «Спам» и «Не спам»? Ваши правила сохранятся.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Отфильтрованные сообщения ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'Ничего не отфильтровано.'; + + @override + String get messageFilter_ghostSingle => + 'Скрытое сообщение · Нажмите, чтобы посмотреть'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count скрытых сообщений · Нажмите, чтобы посмотреть', + many: '$count скрытых сообщений · Нажмите, чтобы посмотреть', + few: '$count скрытых сообщения · Нажмите, чтобы посмотреть', + one: '$count скрытое сообщение · Нажмите, чтобы посмотреть', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Показано скрытое сообщение · Нажмите, чтобы скрыть'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Показано $count скрытых сообщений · Нажмите, чтобы скрыть', + many: 'Показано $count скрытых сообщений · Нажмите, чтобы скрыть', + few: 'Показано $count скрытых сообщения · Нажмите, чтобы скрыть', + one: 'Показано $count скрытое сообщение · Нажмите, чтобы скрыть', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Отфильтровано: совпадает с «$pattern»'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Отфильтровано: отправитель «$pattern»'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Отфильтровано: повторяющиеся символы'; + + @override + String get messageFilter_reasonDuplicate => + 'Отфильтровано: повторное сообщение'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Отфильтровано: одно и то же сообщение от нескольких отправителей'; + + @override + String get messageFilter_reasonLearned => + 'Отфильтровано: похоже на сообщения, которые вы отметили как спам'; + + @override + String get messageFilter_reasonManual => + 'Отфильтровано: вы отметили это как спам'; + + @override + String get messageFilter_notSpam => 'Не спам'; + + @override + String get messageFilter_hideAgain => 'Скрыть'; + + @override + String get messageFilter_markSpam => 'Отметить как спам'; + + @override + String get messageFilter_markedSpam => 'Отмечено как спам'; + + @override + String get messageFilter_markedNotSpam => 'Отмечено как не спам'; + + @override + String get messageFilter_filterSender => 'Фильтровать этого отправителя'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Скрывать все сообщения от «$name»?'; + } + + @override + String get messageFilter_filterLikeThis => 'Фильтровать похожие сообщения…'; + + @override + String get messageFilter_channelToggle => + 'Фильтровать сообщения в этом канале'; + + @override + String get messageFilter_ghostIconTooltip => + 'Скрыто вашим фильтром сообщений'; } diff --git a/lib/l10n/app_localizations_sk.dart b/lib/l10n/app_localizations_sk.dart index 9be22e45..eeb911d3 100644 --- a/lib/l10n/app_localizations_sk.dart +++ b/lib/l10n/app_localizations_sk.dart @@ -1409,11 +1409,11 @@ class AppLocalizationsSk extends AppLocalizations { 'Zobraziť ostatné typy uzlov na mape'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => 'Zobraziť spojenia z online mapy'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Zobrazí spojovacie čiary medzi uzlami z online mapy'; @override String get appSettings_timeFilter => 'Časový filter'; @@ -2695,7 +2695,7 @@ class AppLocalizationsSk extends AppLocalizations { String get map_otherNodes => 'Ostatné uzly'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Zobraziť spojenia z online mapy'; @override String get map_showOverlaps => 'Prekrývanie opakovača kľúča'; @@ -6832,4 +6832,213 @@ class AppLocalizationsSk extends AppLocalizations { @override String get holidayGreeting_newYear => 'Šťastný Nový rok|Úspešný nový rok|Happy New Year'; + + @override + String get messageFilter_title => 'Filter správ'; + + @override + String get messageFilter_settingsSubtitle => 'Skryje spam a opakované správy'; + + @override + String get messageFilter_enabled => 'Filtrovať správy'; + + @override + String get messageFilter_enabledSubtitle => 'Platí pre správy v kanáloch'; + + @override + String get messageFilter_displayTitle => 'Filtrované správy'; + + @override + String get messageFilter_displayPlaceholder => + 'Zobraziť malý zástupný riadok'; + + @override + String get messageFilter_displayHide => 'Úplne skryť'; + + @override + String get messageFilter_displayHideHelp => + 'Skryté správy zostanú v zozname Filtrované správy.'; + + @override + String get messageFilter_rulesSection => 'Vaše pravidlá'; + + @override + String get messageFilter_rulesEmpty => + 'Zatiaľ žiadne pravidlá. Pridajte slovo, frázu alebo meno odosielateľa, aby sa zodpovedajúce správy skryli.'; + + @override + String get messageFilter_addRule => 'Pridať pravidlo'; + + @override + String get messageFilter_editRule => 'Upraviť pravidlo'; + + @override + String get messageFilter_rulePattern => 'Slovo, fráza alebo meno'; + + @override + String get messageFilter_rulePatternHint => 'napr. meshos'; + + @override + String get messageFilter_ruleWhere => 'Hľadať v'; + + @override + String get messageFilter_ruleFieldText => 'Text správy'; + + @override + String get messageFilter_ruleFieldSender => 'Meno odosielateľa'; + + @override + String get messageFilter_ruleFieldBoth => 'Oboje'; + + @override + String get messageFilter_ruleMatch => 'Zhoda'; + + @override + String get messageFilter_ruleMatchContains => 'Obsahuje'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Celé slovo'; + + @override + String get messageFilter_ruleMatchExact => 'Presná'; + + @override + String get messageFilter_ruleDeleted => 'Pravidlo bolo odstránené'; + + @override + String get messageFilter_ruleSaved => 'Pravidlo bolo uložené'; + + @override + String get messageFilter_automaticSection => 'Automatické'; + + @override + String get messageFilter_duplicates => 'Opakované správy'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Rovnaká správa odoslaná znova alebo viacerými odosielateľmi'; + + @override + String get messageFilter_repeatedCharacters => 'Opakované znaky'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Správy ako „aaaaaaaa“ alebo „!!!!!!!!“'; + + @override + String get messageFilter_learning => 'Učiť sa z klepnutí na Spam'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam príkladov spamu a $notSpam príkladov nie spamu'; + } + + @override + String get messageFilter_resetLearning => 'Obnoviť učenie'; + + @override + String get messageFilter_resetLearningConfirm => + 'Zabudnúť všetko, čo sa filter naučil z vašich klepnutí na Spam a Nie spam? Vaše pravidlá zostanú zachované.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Filtrované správy ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'Nič nebolo odfiltrované.'; + + @override + String get messageFilter_ghostSingle => 'Skrytá správa · Klepnutím zobrazíte'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count skrytých správ · Klepnutím zobrazíte', + many: '$count skrytej správy · Klepnutím zobrazíte', + few: '$count skryté správy · Klepnutím zobrazíte', + one: '$count skrytá správa · Klepnutím zobrazíte', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Zobrazená skrytá správa · Klepnutím skryjete'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Zobrazených $count skrytých správ · Klepnutím skryjete', + many: 'Zobrazených $count skrytej správy · Klepnutím skryjete', + few: 'Zobrazené $count skryté správy · Klepnutím skryjete', + one: 'Zobrazená 1 skrytá správa · Klepnutím skryjete', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Odfiltrované: zodpovedá „$pattern“'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Odfiltrované: odosielateľ „$pattern“'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Odfiltrované: opakované znaky'; + + @override + String get messageFilter_reasonDuplicate => 'Odfiltrované: opakovaná správa'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Odfiltrované: rovnaká správa od viacerých odosielateľov'; + + @override + String get messageFilter_reasonLearned => + 'Odfiltrované: podobá sa správam, ktoré ste označili ako spam'; + + @override + String get messageFilter_reasonManual => + 'Odfiltrované: označili ste to ako spam'; + + @override + String get messageFilter_notSpam => 'Nie spam'; + + @override + String get messageFilter_hideAgain => 'Skryť'; + + @override + String get messageFilter_markSpam => 'Označiť ako spam'; + + @override + String get messageFilter_markedSpam => 'Označené ako spam'; + + @override + String get messageFilter_markedNotSpam => 'Označené ako nie spam'; + + @override + String get messageFilter_filterSender => 'Filtrovať tohto odosielateľa'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Skryť všetky správy od „$name“?'; + } + + @override + String get messageFilter_filterLikeThis => 'Filtrovať podobné správy…'; + + @override + String get messageFilter_channelToggle => 'Filtrovať správy v tomto kanáli'; + + @override + String get messageFilter_ghostIconTooltip => 'Skryté vaším filtrom správ'; } diff --git a/lib/l10n/app_localizations_sl.dart b/lib/l10n/app_localizations_sl.dart index 39fece9d..fe89180e 100644 --- a/lib/l10n/app_localizations_sl.dart +++ b/lib/l10n/app_localizations_sl.dart @@ -1407,11 +1407,12 @@ class AppLocalizationsSl extends AppLocalizations { 'Pokaži druge vrste naprav na zemljevidu.'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => + 'Pokaži povezave spletnega zemljevida'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Prikaži povezovalne črte med napravami iz spletnega zemljevida'; @override String get appSettings_timeFilter => 'Filter po času'; @@ -2686,7 +2687,7 @@ class AppLocalizationsSl extends AppLocalizations { String get map_otherNodes => 'Druge vozlišča'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Pokaži povezave spletnega zemljevida'; @override String get map_showOverlaps => 'Prekrivanje ključa ponovnega predvajanja'; @@ -6817,4 +6818,216 @@ class AppLocalizationsSl extends AppLocalizations { @override String get holidayGreeting_newYear => 'Srečno novo leto|Srečno v novem letu|Vse najboljše v novem letu|Happy New Year'; + + @override + String get messageFilter_title => 'Filter sporočil'; + + @override + String get messageFilter_settingsSubtitle => + 'Skrij neželena in ponavljajoča se sporočila'; + + @override + String get messageFilter_enabled => 'Filtriraj sporočila'; + + @override + String get messageFilter_enabledSubtitle => 'Velja za sporočila v kanalih'; + + @override + String get messageFilter_displayTitle => 'Filtrirana sporočila'; + + @override + String get messageFilter_displayPlaceholder => 'Pokaži majhno oznako'; + + @override + String get messageFilter_displayHide => 'Skrij popolnoma'; + + @override + String get messageFilter_displayHideHelp => + 'Skrita sporočila ostanejo na seznamu Filtrirana sporočila.'; + + @override + String get messageFilter_rulesSection => 'Vaša pravila'; + + @override + String get messageFilter_rulesEmpty => + 'Še ni pravil. Dodajte besedo, frazo ali ime pošiljatelja, da skrijete ujemajoča se sporočila.'; + + @override + String get messageFilter_addRule => 'Dodaj pravilo'; + + @override + String get messageFilter_editRule => 'Uredi pravilo'; + + @override + String get messageFilter_rulePattern => 'Beseda, fraza ali ime'; + + @override + String get messageFilter_rulePatternHint => 'npr. meshos'; + + @override + String get messageFilter_ruleWhere => 'Išči v'; + + @override + String get messageFilter_ruleFieldText => 'Besedilo sporočila'; + + @override + String get messageFilter_ruleFieldSender => 'Ime pošiljatelja'; + + @override + String get messageFilter_ruleFieldBoth => 'Oboje'; + + @override + String get messageFilter_ruleMatch => 'Ujemanje'; + + @override + String get messageFilter_ruleMatchContains => 'Vsebuje'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Cela beseda'; + + @override + String get messageFilter_ruleMatchExact => 'Natančno'; + + @override + String get messageFilter_ruleDeleted => 'Pravilo izbrisano'; + + @override + String get messageFilter_ruleSaved => 'Pravilo shranjeno'; + + @override + String get messageFilter_automaticSection => 'Samodejno'; + + @override + String get messageFilter_duplicates => 'Ponavljajoča se sporočila'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Isto sporočilo, poslano znova ali od več pošiljateljev'; + + @override + String get messageFilter_repeatedCharacters => 'Ponavljajoči se znaki'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Sporočila, kot sta „aaaaaaaa“ ali „!!!!!!!!“'; + + @override + String get messageFilter_learning => 'Uči se iz dotikov Neželeno'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return 'Primeri: $spam neželenih in $notSpam ne neželenih'; + } + + @override + String get messageFilter_resetLearning => 'Ponastavi učenje'; + + @override + String get messageFilter_resetLearningConfirm => + 'Pozabim vse, kar se je filter naučil iz vaših dotikov Neželeno in Ni neželeno? Vaša pravila ostanejo.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Filtrirana sporočila ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'Nič ni bilo filtrirano.'; + + @override + String get messageFilter_ghostSingle => + 'Skrito sporočilo · Dotaknite se za ogled'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count skritih sporočil · Dotaknite se za ogled', + few: '$count skrita sporočila · Dotaknite se za ogled', + two: '$count skriti sporočili · Dotaknite se za ogled', + one: '$count skrito sporočilo · Dotaknite se za ogled', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Prikazano skrito sporočilo · Dotaknite se za skritje'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Prikazanih $count skritih sporočil · Dotaknite se za skritje', + few: 'Prikazana $count skrita sporočila · Dotaknite se za skritje', + two: 'Prikazani $count skriti sporočili · Dotaknite se za skritje', + one: 'Prikazano 1 skrito sporočilo · Dotaknite se za skritje', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Filtrirano: ujema se z „$pattern“'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Filtrirano: pošiljatelj „$pattern“'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Filtrirano: ponavljajoči se znaki'; + + @override + String get messageFilter_reasonDuplicate => + 'Filtrirano: ponovljeno sporočilo'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Filtrirano: isto sporočilo od več pošiljateljev'; + + @override + String get messageFilter_reasonLearned => + 'Filtrirano: podobno sporočilom, ki ste jih označili kot neželena'; + + @override + String get messageFilter_reasonManual => + 'Filtrirano: to ste označili kot neželeno'; + + @override + String get messageFilter_notSpam => 'Ni neželeno'; + + @override + String get messageFilter_hideAgain => 'Skrij'; + + @override + String get messageFilter_markSpam => 'Označi kot neželeno'; + + @override + String get messageFilter_markedSpam => 'Označeno kot neželeno'; + + @override + String get messageFilter_markedNotSpam => 'Označeno kot ni neželeno'; + + @override + String get messageFilter_filterSender => 'Filtriraj tega pošiljatelja'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Skrijem vsa sporočila od „$name“?'; + } + + @override + String get messageFilter_filterLikeThis => 'Filtriraj podobna sporočila…'; + + @override + String get messageFilter_channelToggle => 'Filtriraj sporočila v tem kanalu'; + + @override + String get messageFilter_ghostIconTooltip => + 'Skrito z vašim filtrom sporočil'; } diff --git a/lib/l10n/app_localizations_sv.dart b/lib/l10n/app_localizations_sv.dart index d0bae11a..da326617 100644 --- a/lib/l10n/app_localizations_sv.dart +++ b/lib/l10n/app_localizations_sv.dart @@ -1394,11 +1394,12 @@ class AppLocalizationsSv extends AppLocalizations { 'Visa andra nodtyper på kartan'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => + 'Visa anslutningar från onlinekartan'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Visa anslutningslinjer mellan noder från onlinekartan'; @override String get appSettings_timeFilter => 'Tidsfilter'; @@ -2672,7 +2673,7 @@ class AppLocalizationsSv extends AppLocalizations { String get map_otherNodes => 'Andra noder'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Visa anslutningar från onlinekartan'; @override String get map_showOverlaps => 'Repeater-nyckelöverlappningar'; @@ -6790,4 +6791,211 @@ class AppLocalizationsSv extends AppLocalizations { @override String get holidayGreeting_newYear => 'Gott nytt år|Happy New Year|Ett gott nytt år'; + + @override + String get messageFilter_title => 'Meddelandefilter'; + + @override + String get messageFilter_settingsSubtitle => + 'Dölj skräppost och upprepade meddelanden'; + + @override + String get messageFilter_enabled => 'Filtrera meddelanden'; + + @override + String get messageFilter_enabledSubtitle => 'Gäller kanalmeddelanden'; + + @override + String get messageFilter_displayTitle => 'Filtrerade meddelanden'; + + @override + String get messageFilter_displayPlaceholder => 'Visa en liten platshållare'; + + @override + String get messageFilter_displayHide => 'Dölj helt'; + + @override + String get messageFilter_displayHideHelp => + 'Dolda meddelanden finns kvar i listan Filtrerade meddelanden.'; + + @override + String get messageFilter_rulesSection => 'Dina regler'; + + @override + String get messageFilter_rulesEmpty => + 'Inga regler ännu. Lägg till ett ord, en fras eller ett avsändarnamn för att dölja matchande meddelanden.'; + + @override + String get messageFilter_addRule => 'Lägg till regel'; + + @override + String get messageFilter_editRule => 'Redigera regel'; + + @override + String get messageFilter_rulePattern => 'Ord, fras eller namn'; + + @override + String get messageFilter_rulePatternHint => 't.ex. meshos'; + + @override + String get messageFilter_ruleWhere => 'Sök i'; + + @override + String get messageFilter_ruleFieldText => 'Meddelandetext'; + + @override + String get messageFilter_ruleFieldSender => 'Avsändarnamn'; + + @override + String get messageFilter_ruleFieldBoth => 'Båda'; + + @override + String get messageFilter_ruleMatch => 'Matchning'; + + @override + String get messageFilter_ruleMatchContains => 'Innehåller'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Helt ord'; + + @override + String get messageFilter_ruleMatchExact => 'Exakt'; + + @override + String get messageFilter_ruleDeleted => 'Regeln har raderats'; + + @override + String get messageFilter_ruleSaved => 'Regeln har sparats'; + + @override + String get messageFilter_automaticSection => 'Automatiskt'; + + @override + String get messageFilter_duplicates => 'Upprepade meddelanden'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Samma meddelande skickas igen, eller av flera avsändare'; + + @override + String get messageFilter_repeatedCharacters => 'Upprepade tecken'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Meddelanden som ”aaaaaaaa” eller ”!!!!!!!!”'; + + @override + String get messageFilter_learning => 'Lär av tryck på Skräppost'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam skräppost- och $notSpam inte-skräppost-exempel'; + } + + @override + String get messageFilter_resetLearning => 'Återställ inlärning'; + + @override + String get messageFilter_resetLearningConfirm => + 'Glömma allt som lärts från dina tryck på Skräppost och Inte skräppost? Dina regler behålls.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Filtrerade meddelanden ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'Inget har filtrerats.'; + + @override + String get messageFilter_ghostSingle => + 'Dolt meddelande · Tryck för att visa'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count dolda meddelanden · Tryck för att visa', + one: '$count dolt meddelande · Tryck för att visa', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Visar dolt meddelande · Tryck för att dölja'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: 'Visar $count dolda meddelanden · Tryck för att dölja', + one: 'Visar $count dolt meddelande · Tryck för att dölja', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Filtrerat: matchar ”$pattern”'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Filtrerat: avsändare ”$pattern”'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Filtrerat: upprepade tecken'; + + @override + String get messageFilter_reasonDuplicate => 'Filtrerat: upprepat meddelande'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Filtrerat: samma meddelande från flera avsändare'; + + @override + String get messageFilter_reasonLearned => + 'Filtrerat: liknar meddelanden du markerat som skräppost'; + + @override + String get messageFilter_reasonManual => + 'Filtrerat: du markerade detta som skräppost'; + + @override + String get messageFilter_notSpam => 'Inte skräppost'; + + @override + String get messageFilter_hideAgain => 'Dölj'; + + @override + String get messageFilter_markSpam => 'Markera som skräppost'; + + @override + String get messageFilter_markedSpam => 'Markerat som skräppost'; + + @override + String get messageFilter_markedNotSpam => 'Markerat som inte skräppost'; + + @override + String get messageFilter_filterSender => 'Filtrera denna avsändare'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Dölja alla meddelanden från ”$name”?'; + } + + @override + String get messageFilter_filterLikeThis => 'Filtrera meddelanden som detta…'; + + @override + String get messageFilter_channelToggle => + 'Filtrera meddelanden i den här kanalen'; + + @override + String get messageFilter_ghostIconTooltip => 'Dolt av ditt meddelandefilter'; } diff --git a/lib/l10n/app_localizations_uk.dart b/lib/l10n/app_localizations_uk.dart index 38482a52..efc5ddf5 100644 --- a/lib/l10n/app_localizations_uk.dart +++ b/lib/l10n/app_localizations_uk.dart @@ -1411,11 +1411,11 @@ class AppLocalizationsUk extends AppLocalizations { 'Відображати інші типи вузлів на карті'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => 'Показувати зв’язки з онлайн-карти'; @override String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + 'Показує лінії між вузлами з онлайн-карти'; @override String get appSettings_timeFilter => 'Фільтр часу'; @@ -2696,7 +2696,7 @@ class AppLocalizationsUk extends AppLocalizations { String get map_otherNodes => 'Інші вузли'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => 'Показувати зв’язки з онлайн-карти'; @override String get map_showOverlaps => 'Перекриття ключів ретрансляторів'; @@ -6870,4 +6870,222 @@ class AppLocalizationsUk extends AppLocalizations { @override String get holidayGreeting_newYear => 'З Новим роком|З наступаючим Новим роком|Щасливого Нового року|Happy New Year'; + + @override + String get messageFilter_title => 'Фільтр повідомлень'; + + @override + String get messageFilter_settingsSubtitle => + 'Приховує спам і повідомлення, що повторюються'; + + @override + String get messageFilter_enabled => 'Фільтрувати повідомлення'; + + @override + String get messageFilter_enabledSubtitle => + 'Стосується повідомлень у каналах'; + + @override + String get messageFilter_displayTitle => 'Відфільтровані повідомлення'; + + @override + String get messageFilter_displayPlaceholder => + 'Показувати невеликий замінник'; + + @override + String get messageFilter_displayHide => 'Приховати повністю'; + + @override + String get messageFilter_displayHideHelp => + 'Приховані повідомлення залишаються у списку «Відфільтровані повідомлення».'; + + @override + String get messageFilter_rulesSection => 'Ваші правила'; + + @override + String get messageFilter_rulesEmpty => + 'Правил ще немає. Додайте слово, фразу або ім’я відправника, щоб приховувати повідомлення, які їм відповідають.'; + + @override + String get messageFilter_addRule => 'Додати правило'; + + @override + String get messageFilter_editRule => 'Змінити правило'; + + @override + String get messageFilter_rulePattern => 'Слово, фраза або ім’я'; + + @override + String get messageFilter_rulePatternHint => 'напр. meshos'; + + @override + String get messageFilter_ruleWhere => 'Де шукати'; + + @override + String get messageFilter_ruleFieldText => 'Текст повідомлення'; + + @override + String get messageFilter_ruleFieldSender => 'Ім’я відправника'; + + @override + String get messageFilter_ruleFieldBoth => 'Обидва'; + + @override + String get messageFilter_ruleMatch => 'Збіг'; + + @override + String get messageFilter_ruleMatchContains => 'Містить'; + + @override + String get messageFilter_ruleMatchWholeWord => 'Ціле слово'; + + @override + String get messageFilter_ruleMatchExact => 'Точно'; + + @override + String get messageFilter_ruleDeleted => 'Правило видалено'; + + @override + String get messageFilter_ruleSaved => 'Правило збережено'; + + @override + String get messageFilter_automaticSection => 'Автоматично'; + + @override + String get messageFilter_duplicates => 'Повідомлення, що повторюються'; + + @override + String get messageFilter_duplicatesSubtitle => + 'Те саме повідомлення, надіслане знову або кількома відправниками'; + + @override + String get messageFilter_repeatedCharacters => 'Повторювані символи'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + 'Повідомлення на кшталт «aaaaaaaa» або «!!!!!!!!»'; + + @override + String get messageFilter_learning => 'Навчання на натисканнях «Спам»'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam прикладів спаму та $notSpam прикладів не спаму'; + } + + @override + String get messageFilter_resetLearning => 'Скинути навчання'; + + @override + String get messageFilter_resetLearningConfirm => + 'Забути все, чого було навчено натисканнями «Спам» і «Не спам»? Ваші правила буде збережено.'; + + @override + String messageFilter_filteredMessages(int count) { + return 'Відфільтровані повідомлення ($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => 'Нічого не відфільтровано.'; + + @override + String get messageFilter_ghostSingle => + 'Приховане повідомлення · Торкніться, щоб переглянути'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count прихованого повідомлення · Торкніться, щоб переглянути', + many: '$count прихованих повідомлень · Торкніться, щоб переглянути', + few: '$count приховані повідомлення · Торкніться, щоб переглянути', + one: '$count приховане повідомлення · Торкніться, щоб переглянути', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => + 'Показано приховане повідомлення · Торкніться, щоб приховати'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: + 'Показано $count прихованого повідомлення · Торкніться, щоб приховати', + many: + 'Показано $count прихованих повідомлень · Торкніться, щоб приховати', + few: 'Показано $count приховані повідомлення · Торкніться, щоб приховати', + one: 'Показано $count приховане повідомлення · Торкніться, щоб приховати', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return 'Відфільтровано: збігається з «$pattern»'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return 'Відфільтровано: відправник «$pattern»'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => + 'Відфільтровано: повторювані символи'; + + @override + String get messageFilter_reasonDuplicate => + 'Відфільтровано: повідомлення повторюється'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => + 'Відфільтровано: те саме повідомлення від кількох відправників'; + + @override + String get messageFilter_reasonLearned => + 'Відфільтровано: схоже на повідомлення, які ви позначили як спам'; + + @override + String get messageFilter_reasonManual => + 'Відфільтровано: ви позначили це як спам'; + + @override + String get messageFilter_notSpam => 'Не спам'; + + @override + String get messageFilter_hideAgain => 'Приховати'; + + @override + String get messageFilter_markSpam => 'Позначити як спам'; + + @override + String get messageFilter_markedSpam => 'Позначено як спам'; + + @override + String get messageFilter_markedNotSpam => 'Позначено як не спам'; + + @override + String get messageFilter_filterSender => 'Фільтрувати цього відправника'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return 'Приховати всі повідомлення від «$name»?'; + } + + @override + String get messageFilter_filterLikeThis => + 'Фільтрувати повідомлення, схожі на це…'; + + @override + String get messageFilter_channelToggle => + 'Фільтрувати повідомлення в цьому каналі'; + + @override + String get messageFilter_ghostIconTooltip => + 'Приховано вашим фільтром повідомлень'; } diff --git a/lib/l10n/app_localizations_zh.dart b/lib/l10n/app_localizations_zh.dart index d3b0c4c5..40672451 100644 --- a/lib/l10n/app_localizations_zh.dart +++ b/lib/l10n/app_localizations_zh.dart @@ -1321,11 +1321,10 @@ class AppLocalizationsZh extends AppLocalizations { String get appSettings_showOtherNodesSubtitle => '在地图上显示其他节点类型'; @override - String get appSettings_showOnlineLinks => 'Show Online Map Connections'; + String get appSettings_showOnlineLinks => '显示在线地图连接'; @override - String get appSettings_showOnlineLinksSubtitle => - 'Display connection lines between nodes from the online map'; + String get appSettings_showOnlineLinksSubtitle => '显示在线地图中节点之间的连接线'; @override String get appSettings_timeFilter => '时间过滤器'; @@ -2548,7 +2547,7 @@ class AppLocalizationsZh extends AppLocalizations { String get map_otherNodes => '其他节点'; @override - String get map_showOnlineLinks => 'Show Online Map Connections'; + String get map_showOnlineLinks => '显示在线地图连接'; @override String get map_showOverlaps => '重复键重叠'; @@ -6383,4 +6382,198 @@ class AppLocalizationsZh extends AppLocalizations { @override String get holidayGreeting_newYear => '新年快乐|新年快樂|元旦快乐|元旦快樂|新年好|新年愉快'; + + @override + String get messageFilter_title => '消息过滤'; + + @override + String get messageFilter_settingsSubtitle => '隐藏垃圾消息和重复消息'; + + @override + String get messageFilter_enabled => '过滤消息'; + + @override + String get messageFilter_enabledSubtitle => '适用于频道消息'; + + @override + String get messageFilter_displayTitle => '已过滤的消息'; + + @override + String get messageFilter_displayPlaceholder => '显示一个小占位提示'; + + @override + String get messageFilter_displayHide => '完全隐藏'; + + @override + String get messageFilter_displayHideHelp => '被隐藏的消息仍会保留在“已过滤的消息”列表中。'; + + @override + String get messageFilter_rulesSection => '你的规则'; + + @override + String get messageFilter_rulesEmpty => '还没有规则。添加一个词语、短语或发送者名称,即可隐藏匹配的消息。'; + + @override + String get messageFilter_addRule => '添加规则'; + + @override + String get messageFilter_editRule => '编辑规则'; + + @override + String get messageFilter_rulePattern => '词语、短语或名称'; + + @override + String get messageFilter_rulePatternHint => '例如 meshos'; + + @override + String get messageFilter_ruleWhere => '查找范围'; + + @override + String get messageFilter_ruleFieldText => '消息内容'; + + @override + String get messageFilter_ruleFieldSender => '发送者名称'; + + @override + String get messageFilter_ruleFieldBoth => '两者'; + + @override + String get messageFilter_ruleMatch => '匹配方式'; + + @override + String get messageFilter_ruleMatchContains => '包含'; + + @override + String get messageFilter_ruleMatchWholeWord => '完整词语'; + + @override + String get messageFilter_ruleMatchExact => '完全相同'; + + @override + String get messageFilter_ruleDeleted => '规则已删除'; + + @override + String get messageFilter_ruleSaved => '规则已保存'; + + @override + String get messageFilter_automaticSection => '自动'; + + @override + String get messageFilter_duplicates => '重复消息'; + + @override + String get messageFilter_duplicatesSubtitle => '重复发送的相同消息,或多个发送者发送的相同消息'; + + @override + String get messageFilter_repeatedCharacters => '重复字符'; + + @override + String get messageFilter_repeatedCharactersSubtitle => + '类似“aaaaaaaa”或“!!!!!!!!”的消息'; + + @override + String get messageFilter_learning => '从“垃圾消息”点击中学习'; + + @override + String messageFilter_learningSubtitle(int spam, int notSpam) { + return '$spam 个垃圾消息示例和 $notSpam 个非垃圾消息示例'; + } + + @override + String get messageFilter_resetLearning => '重置学习'; + + @override + String get messageFilter_resetLearningConfirm => + '要清除从你点击“垃圾消息”和“非垃圾消息”中学到的所有内容吗?你的规则会保留。'; + + @override + String messageFilter_filteredMessages(int count) { + return '已过滤的消息($count)'; + } + + @override + String get messageFilter_filteredMessagesEmpty => '没有被过滤的消息。'; + + @override + String get messageFilter_ghostSingle => '已隐藏的消息 · 点击查看'; + + @override + String messageFilter_ghostMany(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '$count 条已隐藏的消息 · 点击查看', + ); + return '$_temp0'; + } + + @override + String get messageFilter_ghostSingleExpanded => '正在显示已隐藏的消息 · 点击隐藏'; + + @override + String messageFilter_ghostManyExpanded(int count) { + String _temp0 = intl.Intl.pluralLogic( + count, + locale: localeName, + other: '正在显示 $count 条已隐藏的消息 · 点击隐藏', + ); + return '$_temp0'; + } + + @override + String messageFilter_reasonTextRule(String pattern) { + return '已过滤:匹配“$pattern”'; + } + + @override + String messageFilter_reasonSenderRule(String pattern) { + return '已过滤:发送者“$pattern”'; + } + + @override + String get messageFilter_reasonRepeatedCharacters => '已过滤:重复字符'; + + @override + String get messageFilter_reasonDuplicate => '已过滤:重复消息'; + + @override + String get messageFilter_reasonCrossSenderDuplicate => '已过滤:多个发送者发送的相同消息'; + + @override + String get messageFilter_reasonLearned => '已过滤:与你标记为垃圾消息的内容相似'; + + @override + String get messageFilter_reasonManual => '已过滤:你已将此消息标记为垃圾消息'; + + @override + String get messageFilter_notSpam => '非垃圾消息'; + + @override + String get messageFilter_hideAgain => '隐藏'; + + @override + String get messageFilter_markSpam => '标记为垃圾消息'; + + @override + String get messageFilter_markedSpam => '已标记为垃圾消息'; + + @override + String get messageFilter_markedNotSpam => '已标记为非垃圾消息'; + + @override + String get messageFilter_filterSender => '过滤此发送者'; + + @override + String messageFilter_filterSenderConfirm(String name) { + return '要隐藏来自“$name”的所有消息吗?'; + } + + @override + String get messageFilter_filterLikeThis => '过滤类似的消息…'; + + @override + String get messageFilter_channelToggle => '过滤此频道中的消息'; + + @override + String get messageFilter_ghostIconTooltip => '已被你的消息过滤隐藏'; } diff --git a/lib/l10n/app_nl.arb b/lib/l10n/app_nl.arb index bb6ca89b..8f7de2ab 100644 --- a/lib/l10n/app_nl.arb +++ b/lib/l10n/app_nl.arb @@ -3427,5 +3427,64 @@ "themes_chatBackground": "Chatachtergrond", "themes_chatBackgroundHelp": "Getoond in chats die geen eigen achtergrond hebben", "themes_chatBackgroundEverywhere": "In elke chat gebruiken", - "themes_chatBackgroundEverywhereHelp": "Vervangt ook achtergronden die voor afzonderlijke chats zijn ingesteld" + "themes_chatBackgroundEverywhereHelp": "Vervangt ook achtergronden die voor afzonderlijke chats zijn ingesteld", + "appSettings_showOnlineLinks": "Verbindingen van de online kaart tonen", + "appSettings_showOnlineLinksSubtitle": "Verbindingslijnen tussen nodes van de online kaart tonen", + "map_showOnlineLinks": "Verbindingen van de online kaart tonen", + "messageFilter_title": "Berichtenfilter", + "messageFilter_settingsSubtitle": "Spam en herhaalde berichten verbergen", + "messageFilter_enabled": "Berichten filteren", + "messageFilter_enabledSubtitle": "Geldt voor kanaalberichten", + "messageFilter_displayTitle": "Gefilterde berichten", + "messageFilter_displayPlaceholder": "Een kleine plaatsaanduiding tonen", + "messageFilter_displayHide": "Helemaal verbergen", + "messageFilter_displayHideHelp": "Verborgen berichten blijven in de lijst Gefilterde berichten staan.", + "messageFilter_rulesSection": "Jouw regels", + "messageFilter_rulesEmpty": "Nog geen regels. Voeg een woord, zin of afzendernaam toe om passende berichten te verbergen.", + "messageFilter_addRule": "Regel toevoegen", + "messageFilter_editRule": "Regel bewerken", + "messageFilter_rulePattern": "Woord, zin of naam", + "messageFilter_rulePatternHint": "bijv. meshos", + "messageFilter_ruleWhere": "Zoeken in", + "messageFilter_ruleFieldText": "Berichttekst", + "messageFilter_ruleFieldSender": "Afzendernaam", + "messageFilter_ruleFieldBoth": "Beide", + "messageFilter_ruleMatch": "Overeenkomst", + "messageFilter_ruleMatchContains": "Bevat", + "messageFilter_ruleMatchWholeWord": "Heel woord", + "messageFilter_ruleMatchExact": "Exact", + "messageFilter_ruleDeleted": "Regel verwijderd", + "messageFilter_ruleSaved": "Regel opgeslagen", + "messageFilter_automaticSection": "Automatisch", + "messageFilter_duplicates": "Herhaalde berichten", + "messageFilter_duplicatesSubtitle": "Hetzelfde bericht opnieuw verstuurd, of door meerdere afzenders", + "messageFilter_repeatedCharacters": "Herhaalde tekens", + "messageFilter_repeatedCharactersSubtitle": "Berichten zoals „aaaaaaaa” of „!!!!!!!!”", + "messageFilter_learning": "Leren van Spam-tikken", + "messageFilter_learningSubtitle": "{spam} spam- en {notSpam} geen-spamvoorbeelden", + "messageFilter_resetLearning": "Geleerde gegevens wissen", + "messageFilter_resetLearningConfirm": "Alles vergeten wat is geleerd van je tikken op Spam en Geen spam? Je regels blijven behouden.", + "messageFilter_filteredMessages": "Gefilterde berichten ({count})", + "messageFilter_filteredMessagesEmpty": "Er is niets gefilterd.", + "messageFilter_ghostSingle": "Verborgen bericht · Tik om te bekijken", + "messageFilter_ghostMany": "{count, plural, one{{count} verborgen bericht · Tik om te bekijken} other{{count} verborgen berichten · Tik om te bekijken}}", + "messageFilter_ghostSingleExpanded": "Verborgen bericht wordt getoond · Tik om te verbergen", + "messageFilter_ghostManyExpanded": "{count, plural, =1{1 verborgen bericht wordt getoond · Tik om te verbergen} other{{count} verborgen berichten worden getoond · Tik om te verbergen}}", + "messageFilter_reasonTextRule": "Gefilterd: komt overeen met „{pattern}”", + "messageFilter_reasonSenderRule": "Gefilterd: afzender „{pattern}”", + "messageFilter_reasonRepeatedCharacters": "Gefilterd: herhaalde tekens", + "messageFilter_reasonDuplicate": "Gefilterd: herhaald bericht", + "messageFilter_reasonCrossSenderDuplicate": "Gefilterd: hetzelfde bericht van meerdere afzenders", + "messageFilter_reasonLearned": "Gefilterd: lijkt op berichten die je als spam hebt gemarkeerd", + "messageFilter_reasonManual": "Gefilterd: je hebt dit als spam gemarkeerd", + "messageFilter_notSpam": "Geen spam", + "messageFilter_hideAgain": "Verbergen", + "messageFilter_markSpam": "Markeren als spam", + "messageFilter_markedSpam": "Gemarkeerd als spam", + "messageFilter_markedNotSpam": "Gemarkeerd als geen spam", + "messageFilter_filterSender": "Deze afzender filteren", + "messageFilter_filterSenderConfirm": "Alle berichten van „{name}” verbergen?", + "messageFilter_filterLikeThis": "Berichten zoals dit filteren…", + "messageFilter_channelToggle": "Berichten in dit kanaal filteren", + "messageFilter_ghostIconTooltip": "Verborgen door je berichtenfilter" } diff --git a/lib/l10n/app_pl.arb b/lib/l10n/app_pl.arb index d2e636b4..cc1139a7 100644 --- a/lib/l10n/app_pl.arb +++ b/lib/l10n/app_pl.arb @@ -3559,5 +3559,270 @@ "themes_chatBackground": "Tło czatu", "themes_chatBackgroundHelp": "Pokazywane w czatach, które nie mają własnego tła", "themes_chatBackgroundEverywhere": "Użyj w każdym czacie", - "themes_chatBackgroundEverywhereHelp": "Zastępuje też tła ustawione w pojedynczych czatach" + "themes_chatBackgroundEverywhereHelp": "Zastępuje też tła ustawione w pojedynczych czatach", + "appSettings_showOnlineLinks": "Pokaż połączenia z mapy online", + "appSettings_showOnlineLinksSubtitle": "Wyświetlaj linie połączeń między węzłami z mapy online", + "map_showOnlineLinks": "Pokaż połączenia z mapy online", + "messageFilter_title": "Filtr wiadomości", + "@messageFilter_title": { + "description": "Message filter: Message filter" + }, + "messageFilter_settingsSubtitle": "Ukrywaj spam i powtarzające się wiadomości", + "@messageFilter_settingsSubtitle": { + "description": "Message filter: Hide spam and repeated messages" + }, + "messageFilter_enabled": "Filtruj wiadomości", + "@messageFilter_enabled": { + "description": "Message filter: Filter messages" + }, + "messageFilter_enabledSubtitle": "Dotyczy wiadomości na kanałach", + "@messageFilter_enabledSubtitle": { + "description": "Message filter: Applies to channel messages" + }, + "messageFilter_displayTitle": "Przefiltrowane wiadomości", + "@messageFilter_displayTitle": { + "description": "Message filter: Filtered messages" + }, + "messageFilter_displayPlaceholder": "Pokaż mały znacznik", + "@messageFilter_displayPlaceholder": { + "description": "Message filter: Show a small placeholder" + }, + "messageFilter_displayHide": "Ukryj całkowicie", + "@messageFilter_displayHide": { + "description": "Message filter: Hide completely" + }, + "messageFilter_displayHideHelp": "Ukryte wiadomości pozostają na liście Przefiltrowanych wiadomości.", + "@messageFilter_displayHideHelp": { + "description": "Message filter: Hidden messages stay in the Filtered messages list." + }, + "messageFilter_rulesSection": "Twoje reguły", + "@messageFilter_rulesSection": { + "description": "Message filter: Your rules" + }, + "messageFilter_rulesEmpty": "Brak reguł. Dodaj słowo, wyrażenie lub nazwę nadawcy, aby ukrywać pasujące wiadomości.", + "@messageFilter_rulesEmpty": { + "description": "Message filter: No rules yet. Add a word, phrase or sender name to hide messages that match it." + }, + "messageFilter_addRule": "Dodaj regułę", + "@messageFilter_addRule": { + "description": "Message filter: Add rule" + }, + "messageFilter_editRule": "Edytuj regułę", + "@messageFilter_editRule": { + "description": "Message filter: Edit rule" + }, + "messageFilter_rulePattern": "Słowo, wyrażenie lub nazwa", + "@messageFilter_rulePattern": { + "description": "Message filter: Word, phrase or name" + }, + "messageFilter_rulePatternHint": "np. meshos", + "@messageFilter_rulePatternHint": { + "description": "Message filter: e.g. meshos" + }, + "messageFilter_ruleWhere": "Szukaj w", + "@messageFilter_ruleWhere": { + "description": "Message filter: Look in" + }, + "messageFilter_ruleFieldText": "Treść wiadomości", + "@messageFilter_ruleFieldText": { + "description": "Message filter: Message text" + }, + "messageFilter_ruleFieldSender": "Nazwa nadawcy", + "@messageFilter_ruleFieldSender": { + "description": "Message filter: Sender name" + }, + "messageFilter_ruleFieldBoth": "Oba", + "@messageFilter_ruleFieldBoth": { + "description": "Message filter: Both" + }, + "messageFilter_ruleMatch": "Dopasowanie", + "@messageFilter_ruleMatch": { + "description": "Message filter: Match" + }, + "messageFilter_ruleMatchContains": "Zawiera", + "@messageFilter_ruleMatchContains": { + "description": "Message filter: Contains" + }, + "messageFilter_ruleMatchWholeWord": "Całe słowo", + "@messageFilter_ruleMatchWholeWord": { + "description": "Message filter: Whole word" + }, + "messageFilter_ruleMatchExact": "Dokładne", + "@messageFilter_ruleMatchExact": { + "description": "Message filter: Exact" + }, + "messageFilter_ruleDeleted": "Reguła usunięta", + "@messageFilter_ruleDeleted": { + "description": "Message filter: Rule deleted" + }, + "messageFilter_ruleSaved": "Reguła zapisana", + "@messageFilter_ruleSaved": { + "description": "Message filter: Rule saved" + }, + "messageFilter_automaticSection": "Automatyczne", + "@messageFilter_automaticSection": { + "description": "Message filter: Automatic" + }, + "messageFilter_duplicates": "Powtarzające się wiadomości", + "@messageFilter_duplicates": { + "description": "Message filter: Repeated messages" + }, + "messageFilter_duplicatesSubtitle": "Ta sama wiadomość wysłana ponownie lub przez kilku nadawców", + "@messageFilter_duplicatesSubtitle": { + "description": "Message filter: The same message sent again, or by several senders" + }, + "messageFilter_repeatedCharacters": "Powtarzające się znaki", + "@messageFilter_repeatedCharacters": { + "description": "Message filter: Repeated characters" + }, + "messageFilter_repeatedCharactersSubtitle": "Wiadomości typu „aaaaaaaa” lub „!!!!!!!!”", + "@messageFilter_repeatedCharactersSubtitle": { + "description": "Message filter: Messages like \"aaaaaaaa\" or \"!!!!!!!!\"" + }, + "messageFilter_learning": "Ucz się z oznaczeń Spam", + "@messageFilter_learning": { + "description": "Message filter: Learn from Spam taps" + }, + "messageFilter_learningSubtitle": "Przykłady: {spam} spam i {notSpam} nie-spam", + "@messageFilter_learningSubtitle": { + "description": "Message filter: {spam} spam and {notSpam} not-spam examples", + "placeholders": { + "spam": { + "type": "int" + }, + "notSpam": { + "type": "int" + } + } + }, + "messageFilter_resetLearning": "Zresetuj naukę", + "@messageFilter_resetLearning": { + "description": "Message filter: Reset learning" + }, + "messageFilter_resetLearningConfirm": "Zapomnieć wszystko, czego nauczył się filtr z Twoich oznaczeń Spam i Nie spam? Twoje reguły zostaną zachowane.", + "@messageFilter_resetLearningConfirm": { + "description": "Message filter: Forget everything learned from your Spam and Not spam taps? Your rules are kept." + }, + "messageFilter_filteredMessages": "Przefiltrowane wiadomości ({count})", + "@messageFilter_filteredMessages": { + "description": "Message filter: Filtered messages ({count})", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_filteredMessagesEmpty": "Nic nie zostało przefiltrowane.", + "@messageFilter_filteredMessagesEmpty": { + "description": "Message filter: Nothing has been filtered." + }, + "messageFilter_ghostSingle": "Ukryta wiadomość · Dotknij, aby zobaczyć", + "@messageFilter_ghostSingle": { + "description": "Message filter: Hidden message · Tap to view" + }, + "messageFilter_ghostMany": "{count, plural, one{{count} ukryta wiadomość · Dotknij, aby zobaczyć} few{{count} ukryte wiadomości · Dotknij, aby zobaczyć} many{{count} ukrytych wiadomości · Dotknij, aby zobaczyć} other{{count} ukrytej wiadomości · Dotknij, aby zobaczyć}}", + "@messageFilter_ghostMany": { + "description": "Message filter: {count, plural, one{{count} hidden message · Tap to view} other{{count} hidden messages · Tap to view}}", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_ghostSingleExpanded": "Pokazano ukrytą wiadomość · Dotknij, aby ukryć", + "@messageFilter_ghostSingleExpanded": { + "description": "Header above one revealed filtered message; tapping it hides the message again" + }, + "messageFilter_ghostManyExpanded": "{count, plural, =1{Pokazano 1 ukrytą wiadomość · Dotknij, aby ukryć} few{Pokazano {count} ukryte wiadomości · Dotknij, aby ukryć} many{Pokazano {count} ukrytych wiadomości · Dotknij, aby ukryć} other{Pokazano {count} ukrytej wiadomości · Dotknij, aby ukryć}}", + "@messageFilter_ghostManyExpanded": { + "description": "Header above a revealed run of filtered messages; tapping it hides them again", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_reasonTextRule": "Przefiltrowano: pasuje do „{pattern}”", + "@messageFilter_reasonTextRule": { + "description": "Message filter: Filtered: matches \"{pattern}\"", + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonSenderRule": "Przefiltrowano: nadawca „{pattern}”", + "@messageFilter_reasonSenderRule": { + "description": "Message filter: Filtered: sender \"{pattern}\"", + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonRepeatedCharacters": "Przefiltrowano: powtarzające się znaki", + "@messageFilter_reasonRepeatedCharacters": { + "description": "Message filter: Filtered: repeated characters" + }, + "messageFilter_reasonDuplicate": "Przefiltrowano: powtórzona wiadomość", + "@messageFilter_reasonDuplicate": { + "description": "Message filter: Filtered: repeated message" + }, + "messageFilter_reasonCrossSenderDuplicate": "Przefiltrowano: ta sama wiadomość od kilku nadawców", + "@messageFilter_reasonCrossSenderDuplicate": { + "description": "Message filter: Filtered: same message from several senders" + }, + "messageFilter_reasonLearned": "Przefiltrowano: podobna do wiadomości oznaczonych jako spam", + "@messageFilter_reasonLearned": { + "description": "Message filter: Filtered: looks like messages you marked as spam" + }, + "messageFilter_reasonManual": "Przefiltrowano: oznaczyłeś to jako spam", + "@messageFilter_reasonManual": { + "description": "Message filter: Filtered: you marked this as spam" + }, + "messageFilter_notSpam": "Nie spam", + "@messageFilter_notSpam": { + "description": "Message filter: Not spam" + }, + "messageFilter_hideAgain": "Ukryj", + "@messageFilter_hideAgain": { + "description": "Message filter: Hide" + }, + "messageFilter_markSpam": "Oznacz jako spam", + "@messageFilter_markSpam": { + "description": "Message filter: Mark as spam" + }, + "messageFilter_markedSpam": "Oznaczono jako spam", + "@messageFilter_markedSpam": { + "description": "Message filter: Marked as spam" + }, + "messageFilter_markedNotSpam": "Oznaczono jako nie spam", + "@messageFilter_markedNotSpam": { + "description": "Message filter: Marked as not spam" + }, + "messageFilter_filterSender": "Filtruj tego nadawcę", + "@messageFilter_filterSender": { + "description": "Message filter: Filter this sender" + }, + "messageFilter_filterSenderConfirm": "Ukryć wszystkie wiadomości od „{name}”?", + "@messageFilter_filterSenderConfirm": { + "description": "Message filter: Hide all messages from \"{name}\"?", + "placeholders": { + "name": { + "type": "String" + } + } + }, + "messageFilter_filterLikeThis": "Filtruj podobne wiadomości…", + "@messageFilter_filterLikeThis": { + "description": "Message filter: Filter messages like this…" + }, + "messageFilter_channelToggle": "Filtruj wiadomości na tym kanale", + "@messageFilter_channelToggle": { + "description": "Message filter: Filter messages in this channel" + }, + "messageFilter_ghostIconTooltip": "Ukryte przez Twój filtr wiadomości", + "@messageFilter_ghostIconTooltip": { + "description": "Message filter: Hidden by your message filter" + } } diff --git a/lib/l10n/app_pt.arb b/lib/l10n/app_pt.arb index 58f6143d..0c9f75cb 100644 --- a/lib/l10n/app_pt.arb +++ b/lib/l10n/app_pt.arb @@ -3526,5 +3526,116 @@ "themes_chatBackground": "Fundo da conversa", "themes_chatBackgroundHelp": "Mostrado nas conversas que não têm fundo próprio", "themes_chatBackgroundEverywhere": "Usar em todas as conversas", - "themes_chatBackgroundEverywhereHelp": "Também substitui os fundos definidos em conversas individuais" + "themes_chatBackgroundEverywhereHelp": "Também substitui os fundos definidos em conversas individuais", + "appSettings_showOnlineLinks": "Mostrar conexões do mapa online", + "appSettings_showOnlineLinksSubtitle": "Exibe linhas de conexão entre nós do mapa online", + "map_showOnlineLinks": "Mostrar conexões do mapa online", + "messageFilter_title": "Filtro de mensagens", + "messageFilter_settingsSubtitle": "Oculta mensagens de spam e repetidas", + "messageFilter_enabled": "Filtrar mensagens", + "messageFilter_enabledSubtitle": "Aplica-se às mensagens de canal", + "messageFilter_displayTitle": "Mensagens filtradas", + "messageFilter_displayPlaceholder": "Mostrar um aviso pequeno", + "messageFilter_displayHide": "Ocultar completamente", + "messageFilter_displayHideHelp": "As mensagens ocultas continuam na lista de Mensagens filtradas.", + "messageFilter_rulesSection": "Suas regras", + "messageFilter_rulesEmpty": "Ainda não há regras. Adicione uma palavra, frase ou nome de remetente para ocultar as mensagens que correspondam.", + "messageFilter_addRule": "Adicionar regra", + "messageFilter_editRule": "Editar regra", + "messageFilter_rulePattern": "Palavra, frase ou nome", + "messageFilter_rulePatternHint": "ex.: meshos", + "messageFilter_ruleWhere": "Procurar em", + "messageFilter_ruleFieldText": "Texto da mensagem", + "messageFilter_ruleFieldSender": "Nome do remetente", + "messageFilter_ruleFieldBoth": "Ambos", + "messageFilter_ruleMatch": "Correspondência", + "messageFilter_ruleMatchContains": "Contém", + "messageFilter_ruleMatchWholeWord": "Palavra inteira", + "messageFilter_ruleMatchExact": "Exata", + "messageFilter_ruleDeleted": "Regra excluída", + "messageFilter_ruleSaved": "Regra salva", + "messageFilter_automaticSection": "Automático", + "messageFilter_duplicates": "Mensagens repetidas", + "messageFilter_duplicatesSubtitle": "A mesma mensagem enviada de novo, ou por vários remetentes", + "messageFilter_repeatedCharacters": "Caracteres repetidos", + "messageFilter_repeatedCharactersSubtitle": "Mensagens como \"aaaaaaaa\" ou \"!!!!!!!!\"", + "messageFilter_learning": "Aprender com os toques em Spam", + "messageFilter_learningSubtitle": "{spam} exemplos de spam e {notSpam} de não spam", + "@messageFilter_learningSubtitle": { + "placeholders": { + "spam": { + "type": "int" + }, + "notSpam": { + "type": "int" + } + } + }, + "messageFilter_resetLearning": "Redefinir aprendizado", + "messageFilter_resetLearningConfirm": "Esquecer tudo o que foi aprendido com seus toques em Spam e Não é spam? Suas regras são mantidas.", + "messageFilter_filteredMessages": "Mensagens filtradas ({count})", + "@messageFilter_filteredMessages": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_filteredMessagesEmpty": "Nada foi filtrado.", + "messageFilter_ghostSingle": "Mensagem oculta · Toque para ver", + "messageFilter_ghostMany": "{count, plural, one{{count} mensagem oculta · Toque para ver} other{{count} mensagens ocultas · Toque para ver}}", + "@messageFilter_ghostMany": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_ghostSingleExpanded": "Mostrando mensagem oculta · Toque para ocultar", + "messageFilter_ghostManyExpanded": "{count, plural, =1{Mostrando 1 mensagem oculta · Toque para ocultar} other{Mostrando {count} mensagens ocultas · Toque para ocultar}}", + "@messageFilter_ghostManyExpanded": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_reasonTextRule": "Filtrada: corresponde a \"{pattern}\"", + "@messageFilter_reasonTextRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonSenderRule": "Filtrada: remetente \"{pattern}\"", + "@messageFilter_reasonSenderRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonRepeatedCharacters": "Filtrada: caracteres repetidos", + "messageFilter_reasonDuplicate": "Filtrada: mensagem repetida", + "messageFilter_reasonCrossSenderDuplicate": "Filtrada: a mesma mensagem de vários remetentes", + "messageFilter_reasonLearned": "Filtrada: parece mensagens que você marcou como spam", + "messageFilter_reasonManual": "Filtrada: você a marcou como spam", + "messageFilter_notSpam": "Não é spam", + "messageFilter_hideAgain": "Ocultar", + "messageFilter_markSpam": "Marcar como spam", + "messageFilter_markedSpam": "Marcada como spam", + "messageFilter_markedNotSpam": "Marcada como não spam", + "messageFilter_filterSender": "Filtrar este remetente", + "messageFilter_filterSenderConfirm": "Ocultar todas as mensagens de \"{name}\"?", + "@messageFilter_filterSenderConfirm": { + "placeholders": { + "name": { + "type": "String" + } + } + }, + "messageFilter_filterLikeThis": "Filtrar mensagens como esta…", + "messageFilter_channelToggle": "Filtrar mensagens neste canal", + "messageFilter_ghostIconTooltip": "Oculta pelo seu filtro de mensagens" } diff --git a/lib/l10n/app_ru.arb b/lib/l10n/app_ru.arb index e3077cb4..054e20e8 100644 --- a/lib/l10n/app_ru.arb +++ b/lib/l10n/app_ru.arb @@ -2823,5 +2823,64 @@ "themes_chatBackground": "Фон чата", "themes_chatBackgroundHelp": "Показывается в чатах, у которых нет своего фона", "themes_chatBackgroundEverywhere": "Использовать во всех чатах", - "themes_chatBackgroundEverywhereHelp": "Также заменяет фоны, заданные в отдельных чатах" + "themes_chatBackgroundEverywhereHelp": "Также заменяет фоны, заданные в отдельных чатах", + "appSettings_showOnlineLinks": "Показывать связи с онлайн-карты", + "appSettings_showOnlineLinksSubtitle": "Показывать линии связи между узлами с онлайн-карты", + "map_showOnlineLinks": "Показывать связи с онлайн-карты", + "messageFilter_title": "Фильтр сообщений", + "messageFilter_settingsSubtitle": "Скрывать спам и повторяющиеся сообщения", + "messageFilter_enabled": "Фильтровать сообщения", + "messageFilter_enabledSubtitle": "Действует для сообщений в каналах", + "messageFilter_displayTitle": "Отфильтрованные сообщения", + "messageFilter_displayPlaceholder": "Показывать небольшую заглушку", + "messageFilter_displayHide": "Скрывать полностью", + "messageFilter_displayHideHelp": "Скрытые сообщения остаются в списке «Отфильтрованные сообщения».", + "messageFilter_rulesSection": "Ваши правила", + "messageFilter_rulesEmpty": "Правил пока нет. Добавьте слово, фразу или имя отправителя, чтобы скрывать подходящие сообщения.", + "messageFilter_addRule": "Добавить правило", + "messageFilter_editRule": "Изменить правило", + "messageFilter_rulePattern": "Слово, фраза или имя", + "messageFilter_rulePatternHint": "например, meshos", + "messageFilter_ruleWhere": "Где искать", + "messageFilter_ruleFieldText": "Текст сообщения", + "messageFilter_ruleFieldSender": "Имя отправителя", + "messageFilter_ruleFieldBoth": "И то и другое", + "messageFilter_ruleMatch": "Совпадение", + "messageFilter_ruleMatchContains": "Содержит", + "messageFilter_ruleMatchWholeWord": "Целое слово", + "messageFilter_ruleMatchExact": "Точное", + "messageFilter_ruleDeleted": "Правило удалено", + "messageFilter_ruleSaved": "Правило сохранено", + "messageFilter_automaticSection": "Автоматически", + "messageFilter_duplicates": "Повторяющиеся сообщения", + "messageFilter_duplicatesSubtitle": "Одно и то же сообщение, отправленное снова или несколькими отправителями", + "messageFilter_repeatedCharacters": "Повторяющиеся символы", + "messageFilter_repeatedCharactersSubtitle": "Сообщения вроде «aaaaaaaa» или «!!!!!!!!»", + "messageFilter_learning": "Учиться на нажатиях «Спам»", + "messageFilter_learningSubtitle": "Примеров спама: {spam}, не спама: {notSpam}", + "messageFilter_resetLearning": "Сбросить обучение", + "messageFilter_resetLearningConfirm": "Забыть всё, чему фильтр научился на ваших нажатиях «Спам» и «Не спам»? Ваши правила сохранятся.", + "messageFilter_filteredMessages": "Отфильтрованные сообщения ({count})", + "messageFilter_filteredMessagesEmpty": "Ничего не отфильтровано.", + "messageFilter_ghostSingle": "Скрытое сообщение · Нажмите, чтобы посмотреть", + "messageFilter_ghostMany": "{count, plural, one{{count} скрытое сообщение · Нажмите, чтобы посмотреть} few{{count} скрытых сообщения · Нажмите, чтобы посмотреть} many{{count} скрытых сообщений · Нажмите, чтобы посмотреть} other{{count} скрытых сообщений · Нажмите, чтобы посмотреть}}", + "messageFilter_ghostSingleExpanded": "Показано скрытое сообщение · Нажмите, чтобы скрыть", + "messageFilter_ghostManyExpanded": "{count, plural, one{Показано {count} скрытое сообщение · Нажмите, чтобы скрыть} few{Показано {count} скрытых сообщения · Нажмите, чтобы скрыть} many{Показано {count} скрытых сообщений · Нажмите, чтобы скрыть} other{Показано {count} скрытых сообщений · Нажмите, чтобы скрыть}}", + "messageFilter_reasonTextRule": "Отфильтровано: совпадает с «{pattern}»", + "messageFilter_reasonSenderRule": "Отфильтровано: отправитель «{pattern}»", + "messageFilter_reasonRepeatedCharacters": "Отфильтровано: повторяющиеся символы", + "messageFilter_reasonDuplicate": "Отфильтровано: повторное сообщение", + "messageFilter_reasonCrossSenderDuplicate": "Отфильтровано: одно и то же сообщение от нескольких отправителей", + "messageFilter_reasonLearned": "Отфильтровано: похоже на сообщения, которые вы отметили как спам", + "messageFilter_reasonManual": "Отфильтровано: вы отметили это как спам", + "messageFilter_notSpam": "Не спам", + "messageFilter_hideAgain": "Скрыть", + "messageFilter_markSpam": "Отметить как спам", + "messageFilter_markedSpam": "Отмечено как спам", + "messageFilter_markedNotSpam": "Отмечено как не спам", + "messageFilter_filterSender": "Фильтровать этого отправителя", + "messageFilter_filterSenderConfirm": "Скрывать все сообщения от «{name}»?", + "messageFilter_filterLikeThis": "Фильтровать похожие сообщения…", + "messageFilter_channelToggle": "Фильтровать сообщения в этом канале", + "messageFilter_ghostIconTooltip": "Скрыто вашим фильтром сообщений" } diff --git a/lib/l10n/app_sk.arb b/lib/l10n/app_sk.arb index 328979fa..e5e4d991 100644 --- a/lib/l10n/app_sk.arb +++ b/lib/l10n/app_sk.arb @@ -3527,5 +3527,116 @@ "themes_chatBackground": "Pozadie chatu", "themes_chatBackgroundHelp": "Zobrazuje sa v chatoch, ktoré nemajú vlastné pozadie", "themes_chatBackgroundEverywhere": "Použiť v každom chate", - "themes_chatBackgroundEverywhereHelp": "Nahradí aj pozadia nastavené v jednotlivých chatoch" + "themes_chatBackgroundEverywhereHelp": "Nahradí aj pozadia nastavené v jednotlivých chatoch", + "appSettings_showOnlineLinks": "Zobraziť spojenia z online mapy", + "appSettings_showOnlineLinksSubtitle": "Zobrazí spojovacie čiary medzi uzlami z online mapy", + "map_showOnlineLinks": "Zobraziť spojenia z online mapy", + "messageFilter_title": "Filter správ", + "messageFilter_settingsSubtitle": "Skryje spam a opakované správy", + "messageFilter_enabled": "Filtrovať správy", + "messageFilter_enabledSubtitle": "Platí pre správy v kanáloch", + "messageFilter_displayTitle": "Filtrované správy", + "messageFilter_displayPlaceholder": "Zobraziť malý zástupný riadok", + "messageFilter_displayHide": "Úplne skryť", + "messageFilter_displayHideHelp": "Skryté správy zostanú v zozname Filtrované správy.", + "messageFilter_rulesSection": "Vaše pravidlá", + "messageFilter_rulesEmpty": "Zatiaľ žiadne pravidlá. Pridajte slovo, frázu alebo meno odosielateľa, aby sa zodpovedajúce správy skryli.", + "messageFilter_addRule": "Pridať pravidlo", + "messageFilter_editRule": "Upraviť pravidlo", + "messageFilter_rulePattern": "Slovo, fráza alebo meno", + "messageFilter_rulePatternHint": "napr. meshos", + "messageFilter_ruleWhere": "Hľadať v", + "messageFilter_ruleFieldText": "Text správy", + "messageFilter_ruleFieldSender": "Meno odosielateľa", + "messageFilter_ruleFieldBoth": "Oboje", + "messageFilter_ruleMatch": "Zhoda", + "messageFilter_ruleMatchContains": "Obsahuje", + "messageFilter_ruleMatchWholeWord": "Celé slovo", + "messageFilter_ruleMatchExact": "Presná", + "messageFilter_ruleDeleted": "Pravidlo bolo odstránené", + "messageFilter_ruleSaved": "Pravidlo bolo uložené", + "messageFilter_automaticSection": "Automatické", + "messageFilter_duplicates": "Opakované správy", + "messageFilter_duplicatesSubtitle": "Rovnaká správa odoslaná znova alebo viacerými odosielateľmi", + "messageFilter_repeatedCharacters": "Opakované znaky", + "messageFilter_repeatedCharactersSubtitle": "Správy ako „aaaaaaaa“ alebo „!!!!!!!!“", + "messageFilter_learning": "Učiť sa z klepnutí na Spam", + "messageFilter_learningSubtitle": "{spam} príkladov spamu a {notSpam} príkladov nie spamu", + "@messageFilter_learningSubtitle": { + "placeholders": { + "spam": { + "type": "int" + }, + "notSpam": { + "type": "int" + } + } + }, + "messageFilter_resetLearning": "Obnoviť učenie", + "messageFilter_resetLearningConfirm": "Zabudnúť všetko, čo sa filter naučil z vašich klepnutí na Spam a Nie spam? Vaše pravidlá zostanú zachované.", + "messageFilter_filteredMessages": "Filtrované správy ({count})", + "@messageFilter_filteredMessages": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_filteredMessagesEmpty": "Nič nebolo odfiltrované.", + "messageFilter_ghostSingle": "Skrytá správa · Klepnutím zobrazíte", + "messageFilter_ghostMany": "{count, plural, one{{count} skrytá správa · Klepnutím zobrazíte} few{{count} skryté správy · Klepnutím zobrazíte} many{{count} skrytej správy · Klepnutím zobrazíte} other{{count} skrytých správ · Klepnutím zobrazíte}}", + "@messageFilter_ghostMany": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_ghostSingleExpanded": "Zobrazená skrytá správa · Klepnutím skryjete", + "messageFilter_ghostManyExpanded": "{count, plural, =1{Zobrazená 1 skrytá správa · Klepnutím skryjete} few{Zobrazené {count} skryté správy · Klepnutím skryjete} many{Zobrazených {count} skrytej správy · Klepnutím skryjete} other{Zobrazených {count} skrytých správ · Klepnutím skryjete}}", + "@messageFilter_ghostManyExpanded": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_reasonTextRule": "Odfiltrované: zodpovedá „{pattern}“", + "@messageFilter_reasonTextRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonSenderRule": "Odfiltrované: odosielateľ „{pattern}“", + "@messageFilter_reasonSenderRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonRepeatedCharacters": "Odfiltrované: opakované znaky", + "messageFilter_reasonDuplicate": "Odfiltrované: opakovaná správa", + "messageFilter_reasonCrossSenderDuplicate": "Odfiltrované: rovnaká správa od viacerých odosielateľov", + "messageFilter_reasonLearned": "Odfiltrované: podobá sa správam, ktoré ste označili ako spam", + "messageFilter_reasonManual": "Odfiltrované: označili ste to ako spam", + "messageFilter_notSpam": "Nie spam", + "messageFilter_hideAgain": "Skryť", + "messageFilter_markSpam": "Označiť ako spam", + "messageFilter_markedSpam": "Označené ako spam", + "messageFilter_markedNotSpam": "Označené ako nie spam", + "messageFilter_filterSender": "Filtrovať tohto odosielateľa", + "messageFilter_filterSenderConfirm": "Skryť všetky správy od „{name}“?", + "@messageFilter_filterSenderConfirm": { + "placeholders": { + "name": { + "type": "String" + } + } + }, + "messageFilter_filterLikeThis": "Filtrovať podobné správy…", + "messageFilter_channelToggle": "Filtrovať správy v tomto kanáli", + "messageFilter_ghostIconTooltip": "Skryté vaším filtrom správ" } diff --git a/lib/l10n/app_sl.arb b/lib/l10n/app_sl.arb index cbd5a560..f86750da 100644 --- a/lib/l10n/app_sl.arb +++ b/lib/l10n/app_sl.arb @@ -3527,5 +3527,270 @@ "themes_chatBackground": "Ozadje klepeta", "themes_chatBackgroundHelp": "Prikazano v klepetih, ki nimajo svojega ozadja", "themes_chatBackgroundEverywhere": "Uporabi v vseh klepetih", - "themes_chatBackgroundEverywhereHelp": "Zamenja tudi ozadja, nastavljena v posameznih klepetih" + "themes_chatBackgroundEverywhereHelp": "Zamenja tudi ozadja, nastavljena v posameznih klepetih", + "appSettings_showOnlineLinks": "Pokaži povezave spletnega zemljevida", + "appSettings_showOnlineLinksSubtitle": "Prikaži povezovalne črte med napravami iz spletnega zemljevida", + "map_showOnlineLinks": "Pokaži povezave spletnega zemljevida", + "messageFilter_title": "Filter sporočil", + "@messageFilter_title": { + "description": "Message filter: Message filter" + }, + "messageFilter_settingsSubtitle": "Skrij neželena in ponavljajoča se sporočila", + "@messageFilter_settingsSubtitle": { + "description": "Message filter: Hide spam and repeated messages" + }, + "messageFilter_enabled": "Filtriraj sporočila", + "@messageFilter_enabled": { + "description": "Message filter: Filter messages" + }, + "messageFilter_enabledSubtitle": "Velja za sporočila v kanalih", + "@messageFilter_enabledSubtitle": { + "description": "Message filter: Applies to channel messages" + }, + "messageFilter_displayTitle": "Filtrirana sporočila", + "@messageFilter_displayTitle": { + "description": "Message filter: Filtered messages" + }, + "messageFilter_displayPlaceholder": "Pokaži majhno oznako", + "@messageFilter_displayPlaceholder": { + "description": "Message filter: Show a small placeholder" + }, + "messageFilter_displayHide": "Skrij popolnoma", + "@messageFilter_displayHide": { + "description": "Message filter: Hide completely" + }, + "messageFilter_displayHideHelp": "Skrita sporočila ostanejo na seznamu Filtrirana sporočila.", + "@messageFilter_displayHideHelp": { + "description": "Message filter: Hidden messages stay in the Filtered messages list." + }, + "messageFilter_rulesSection": "Vaša pravila", + "@messageFilter_rulesSection": { + "description": "Message filter: Your rules" + }, + "messageFilter_rulesEmpty": "Še ni pravil. Dodajte besedo, frazo ali ime pošiljatelja, da skrijete ujemajoča se sporočila.", + "@messageFilter_rulesEmpty": { + "description": "Message filter: No rules yet. Add a word, phrase or sender name to hide messages that match it." + }, + "messageFilter_addRule": "Dodaj pravilo", + "@messageFilter_addRule": { + "description": "Message filter: Add rule" + }, + "messageFilter_editRule": "Uredi pravilo", + "@messageFilter_editRule": { + "description": "Message filter: Edit rule" + }, + "messageFilter_rulePattern": "Beseda, fraza ali ime", + "@messageFilter_rulePattern": { + "description": "Message filter: Word, phrase or name" + }, + "messageFilter_rulePatternHint": "npr. meshos", + "@messageFilter_rulePatternHint": { + "description": "Message filter: e.g. meshos" + }, + "messageFilter_ruleWhere": "Išči v", + "@messageFilter_ruleWhere": { + "description": "Message filter: Look in" + }, + "messageFilter_ruleFieldText": "Besedilo sporočila", + "@messageFilter_ruleFieldText": { + "description": "Message filter: Message text" + }, + "messageFilter_ruleFieldSender": "Ime pošiljatelja", + "@messageFilter_ruleFieldSender": { + "description": "Message filter: Sender name" + }, + "messageFilter_ruleFieldBoth": "Oboje", + "@messageFilter_ruleFieldBoth": { + "description": "Message filter: Both" + }, + "messageFilter_ruleMatch": "Ujemanje", + "@messageFilter_ruleMatch": { + "description": "Message filter: Match" + }, + "messageFilter_ruleMatchContains": "Vsebuje", + "@messageFilter_ruleMatchContains": { + "description": "Message filter: Contains" + }, + "messageFilter_ruleMatchWholeWord": "Cela beseda", + "@messageFilter_ruleMatchWholeWord": { + "description": "Message filter: Whole word" + }, + "messageFilter_ruleMatchExact": "Natančno", + "@messageFilter_ruleMatchExact": { + "description": "Message filter: Exact" + }, + "messageFilter_ruleDeleted": "Pravilo izbrisano", + "@messageFilter_ruleDeleted": { + "description": "Message filter: Rule deleted" + }, + "messageFilter_ruleSaved": "Pravilo shranjeno", + "@messageFilter_ruleSaved": { + "description": "Message filter: Rule saved" + }, + "messageFilter_automaticSection": "Samodejno", + "@messageFilter_automaticSection": { + "description": "Message filter: Automatic" + }, + "messageFilter_duplicates": "Ponavljajoča se sporočila", + "@messageFilter_duplicates": { + "description": "Message filter: Repeated messages" + }, + "messageFilter_duplicatesSubtitle": "Isto sporočilo, poslano znova ali od več pošiljateljev", + "@messageFilter_duplicatesSubtitle": { + "description": "Message filter: The same message sent again, or by several senders" + }, + "messageFilter_repeatedCharacters": "Ponavljajoči se znaki", + "@messageFilter_repeatedCharacters": { + "description": "Message filter: Repeated characters" + }, + "messageFilter_repeatedCharactersSubtitle": "Sporočila, kot sta „aaaaaaaa“ ali „!!!!!!!!“", + "@messageFilter_repeatedCharactersSubtitle": { + "description": "Message filter: Messages like \"aaaaaaaa\" or \"!!!!!!!!\"" + }, + "messageFilter_learning": "Uči se iz dotikov Neželeno", + "@messageFilter_learning": { + "description": "Message filter: Learn from Spam taps" + }, + "messageFilter_learningSubtitle": "Primeri: {spam} neželenih in {notSpam} ne neželenih", + "@messageFilter_learningSubtitle": { + "description": "Message filter: {spam} spam and {notSpam} not-spam examples", + "placeholders": { + "spam": { + "type": "int" + }, + "notSpam": { + "type": "int" + } + } + }, + "messageFilter_resetLearning": "Ponastavi učenje", + "@messageFilter_resetLearning": { + "description": "Message filter: Reset learning" + }, + "messageFilter_resetLearningConfirm": "Pozabim vse, kar se je filter naučil iz vaših dotikov Neželeno in Ni neželeno? Vaša pravila ostanejo.", + "@messageFilter_resetLearningConfirm": { + "description": "Message filter: Forget everything learned from your Spam and Not spam taps? Your rules are kept." + }, + "messageFilter_filteredMessages": "Filtrirana sporočila ({count})", + "@messageFilter_filteredMessages": { + "description": "Message filter: Filtered messages ({count})", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_filteredMessagesEmpty": "Nič ni bilo filtrirano.", + "@messageFilter_filteredMessagesEmpty": { + "description": "Message filter: Nothing has been filtered." + }, + "messageFilter_ghostSingle": "Skrito sporočilo · Dotaknite se za ogled", + "@messageFilter_ghostSingle": { + "description": "Message filter: Hidden message · Tap to view" + }, + "messageFilter_ghostMany": "{count, plural, one{{count} skrito sporočilo · Dotaknite se za ogled} two{{count} skriti sporočili · Dotaknite se za ogled} few{{count} skrita sporočila · Dotaknite se za ogled} other{{count} skritih sporočil · Dotaknite se za ogled}}", + "@messageFilter_ghostMany": { + "description": "Message filter: {count, plural, one{{count} hidden message · Tap to view} other{{count} hidden messages · Tap to view}}", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_ghostSingleExpanded": "Prikazano skrito sporočilo · Dotaknite se za skritje", + "@messageFilter_ghostSingleExpanded": { + "description": "Header above one revealed filtered message; tapping it hides the message again" + }, + "messageFilter_ghostManyExpanded": "{count, plural, =1{Prikazano 1 skrito sporočilo · Dotaknite se za skritje} two{Prikazani {count} skriti sporočili · Dotaknite se za skritje} few{Prikazana {count} skrita sporočila · Dotaknite se za skritje} other{Prikazanih {count} skritih sporočil · Dotaknite se za skritje}}", + "@messageFilter_ghostManyExpanded": { + "description": "Header above a revealed run of filtered messages; tapping it hides them again", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_reasonTextRule": "Filtrirano: ujema se z „{pattern}“", + "@messageFilter_reasonTextRule": { + "description": "Message filter: Filtered: matches \"{pattern}\"", + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonSenderRule": "Filtrirano: pošiljatelj „{pattern}“", + "@messageFilter_reasonSenderRule": { + "description": "Message filter: Filtered: sender \"{pattern}\"", + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonRepeatedCharacters": "Filtrirano: ponavljajoči se znaki", + "@messageFilter_reasonRepeatedCharacters": { + "description": "Message filter: Filtered: repeated characters" + }, + "messageFilter_reasonDuplicate": "Filtrirano: ponovljeno sporočilo", + "@messageFilter_reasonDuplicate": { + "description": "Message filter: Filtered: repeated message" + }, + "messageFilter_reasonCrossSenderDuplicate": "Filtrirano: isto sporočilo od več pošiljateljev", + "@messageFilter_reasonCrossSenderDuplicate": { + "description": "Message filter: Filtered: same message from several senders" + }, + "messageFilter_reasonLearned": "Filtrirano: podobno sporočilom, ki ste jih označili kot neželena", + "@messageFilter_reasonLearned": { + "description": "Message filter: Filtered: looks like messages you marked as spam" + }, + "messageFilter_reasonManual": "Filtrirano: to ste označili kot neželeno", + "@messageFilter_reasonManual": { + "description": "Message filter: Filtered: you marked this as spam" + }, + "messageFilter_notSpam": "Ni neželeno", + "@messageFilter_notSpam": { + "description": "Message filter: Not spam" + }, + "messageFilter_hideAgain": "Skrij", + "@messageFilter_hideAgain": { + "description": "Message filter: Hide" + }, + "messageFilter_markSpam": "Označi kot neželeno", + "@messageFilter_markSpam": { + "description": "Message filter: Mark as spam" + }, + "messageFilter_markedSpam": "Označeno kot neželeno", + "@messageFilter_markedSpam": { + "description": "Message filter: Marked as spam" + }, + "messageFilter_markedNotSpam": "Označeno kot ni neželeno", + "@messageFilter_markedNotSpam": { + "description": "Message filter: Marked as not spam" + }, + "messageFilter_filterSender": "Filtriraj tega pošiljatelja", + "@messageFilter_filterSender": { + "description": "Message filter: Filter this sender" + }, + "messageFilter_filterSenderConfirm": "Skrijem vsa sporočila od „{name}“?", + "@messageFilter_filterSenderConfirm": { + "description": "Message filter: Hide all messages from \"{name}\"?", + "placeholders": { + "name": { + "type": "String" + } + } + }, + "messageFilter_filterLikeThis": "Filtriraj podobna sporočila…", + "@messageFilter_filterLikeThis": { + "description": "Message filter: Filter messages like this…" + }, + "messageFilter_channelToggle": "Filtriraj sporočila v tem kanalu", + "@messageFilter_channelToggle": { + "description": "Message filter: Filter messages in this channel" + }, + "messageFilter_ghostIconTooltip": "Skrito z vašim filtrom sporočil", + "@messageFilter_ghostIconTooltip": { + "description": "Message filter: Hidden by your message filter" + } } diff --git a/lib/l10n/app_sv.arb b/lib/l10n/app_sv.arb index d372bd24..26741f1d 100644 --- a/lib/l10n/app_sv.arb +++ b/lib/l10n/app_sv.arb @@ -3521,5 +3521,116 @@ "themes_chatBackground": "Chattbakgrund", "themes_chatBackgroundHelp": "Visas i chattar som inte har en egen bakgrund", "themes_chatBackgroundEverywhere": "Använd i alla chattar", - "themes_chatBackgroundEverywhereHelp": "Ersätter även bakgrunder som är inställda för enskilda chattar" + "themes_chatBackgroundEverywhereHelp": "Ersätter även bakgrunder som är inställda för enskilda chattar", + "appSettings_showOnlineLinks": "Visa anslutningar från onlinekartan", + "appSettings_showOnlineLinksSubtitle": "Visa anslutningslinjer mellan noder från onlinekartan", + "map_showOnlineLinks": "Visa anslutningar från onlinekartan", + "messageFilter_title": "Meddelandefilter", + "messageFilter_settingsSubtitle": "Dölj skräppost och upprepade meddelanden", + "messageFilter_enabled": "Filtrera meddelanden", + "messageFilter_enabledSubtitle": "Gäller kanalmeddelanden", + "messageFilter_displayTitle": "Filtrerade meddelanden", + "messageFilter_displayPlaceholder": "Visa en liten platshållare", + "messageFilter_displayHide": "Dölj helt", + "messageFilter_displayHideHelp": "Dolda meddelanden finns kvar i listan Filtrerade meddelanden.", + "messageFilter_rulesSection": "Dina regler", + "messageFilter_rulesEmpty": "Inga regler ännu. Lägg till ett ord, en fras eller ett avsändarnamn för att dölja matchande meddelanden.", + "messageFilter_addRule": "Lägg till regel", + "messageFilter_editRule": "Redigera regel", + "messageFilter_rulePattern": "Ord, fras eller namn", + "messageFilter_rulePatternHint": "t.ex. meshos", + "messageFilter_ruleWhere": "Sök i", + "messageFilter_ruleFieldText": "Meddelandetext", + "messageFilter_ruleFieldSender": "Avsändarnamn", + "messageFilter_ruleFieldBoth": "Båda", + "messageFilter_ruleMatch": "Matchning", + "messageFilter_ruleMatchContains": "Innehåller", + "messageFilter_ruleMatchWholeWord": "Helt ord", + "messageFilter_ruleMatchExact": "Exakt", + "messageFilter_ruleDeleted": "Regeln har raderats", + "messageFilter_ruleSaved": "Regeln har sparats", + "messageFilter_automaticSection": "Automatiskt", + "messageFilter_duplicates": "Upprepade meddelanden", + "messageFilter_duplicatesSubtitle": "Samma meddelande skickas igen, eller av flera avsändare", + "messageFilter_repeatedCharacters": "Upprepade tecken", + "messageFilter_repeatedCharactersSubtitle": "Meddelanden som ”aaaaaaaa” eller ”!!!!!!!!”", + "messageFilter_learning": "Lär av tryck på Skräppost", + "messageFilter_learningSubtitle": "{spam} skräppost- och {notSpam} inte-skräppost-exempel", + "@messageFilter_learningSubtitle": { + "placeholders": { + "spam": { + "type": "int" + }, + "notSpam": { + "type": "int" + } + } + }, + "messageFilter_resetLearning": "Återställ inlärning", + "messageFilter_resetLearningConfirm": "Glömma allt som lärts från dina tryck på Skräppost och Inte skräppost? Dina regler behålls.", + "messageFilter_filteredMessages": "Filtrerade meddelanden ({count})", + "@messageFilter_filteredMessages": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_filteredMessagesEmpty": "Inget har filtrerats.", + "messageFilter_ghostSingle": "Dolt meddelande · Tryck för att visa", + "messageFilter_ghostMany": "{count, plural, one{{count} dolt meddelande · Tryck för att visa} other{{count} dolda meddelanden · Tryck för att visa}}", + "@messageFilter_ghostMany": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_ghostSingleExpanded": "Visar dolt meddelande · Tryck för att dölja", + "messageFilter_ghostManyExpanded": "{count, plural, one{Visar {count} dolt meddelande · Tryck för att dölja} other{Visar {count} dolda meddelanden · Tryck för att dölja}}", + "@messageFilter_ghostManyExpanded": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_reasonTextRule": "Filtrerat: matchar ”{pattern}”", + "@messageFilter_reasonTextRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonSenderRule": "Filtrerat: avsändare ”{pattern}”", + "@messageFilter_reasonSenderRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonRepeatedCharacters": "Filtrerat: upprepade tecken", + "messageFilter_reasonDuplicate": "Filtrerat: upprepat meddelande", + "messageFilter_reasonCrossSenderDuplicate": "Filtrerat: samma meddelande från flera avsändare", + "messageFilter_reasonLearned": "Filtrerat: liknar meddelanden du markerat som skräppost", + "messageFilter_reasonManual": "Filtrerat: du markerade detta som skräppost", + "messageFilter_notSpam": "Inte skräppost", + "messageFilter_hideAgain": "Dölj", + "messageFilter_markSpam": "Markera som skräppost", + "messageFilter_markedSpam": "Markerat som skräppost", + "messageFilter_markedNotSpam": "Markerat som inte skräppost", + "messageFilter_filterSender": "Filtrera denna avsändare", + "messageFilter_filterSenderConfirm": "Dölja alla meddelanden från ”{name}”?", + "@messageFilter_filterSenderConfirm": { + "placeholders": { + "name": { + "type": "String" + } + } + }, + "messageFilter_filterLikeThis": "Filtrera meddelanden som detta…", + "messageFilter_channelToggle": "Filtrera meddelanden i den här kanalen", + "messageFilter_ghostIconTooltip": "Dolt av ditt meddelandefilter" } diff --git a/lib/l10n/app_uk.arb b/lib/l10n/app_uk.arb index 04736e28..870e67d1 100644 --- a/lib/l10n/app_uk.arb +++ b/lib/l10n/app_uk.arb @@ -3506,5 +3506,64 @@ "themes_chatBackground": "Тло чату", "themes_chatBackgroundHelp": "Показується в чатах, які не мають власного тла", "themes_chatBackgroundEverywhere": "Використовувати в усіх чатах", - "themes_chatBackgroundEverywhereHelp": "Також замінює тла, задані в окремих чатах" + "themes_chatBackgroundEverywhereHelp": "Також замінює тла, задані в окремих чатах", + "appSettings_showOnlineLinks": "Показувати зв’язки з онлайн-карти", + "appSettings_showOnlineLinksSubtitle": "Показує лінії між вузлами з онлайн-карти", + "map_showOnlineLinks": "Показувати зв’язки з онлайн-карти", + "messageFilter_title": "Фільтр повідомлень", + "messageFilter_settingsSubtitle": "Приховує спам і повідомлення, що повторюються", + "messageFilter_enabled": "Фільтрувати повідомлення", + "messageFilter_enabledSubtitle": "Стосується повідомлень у каналах", + "messageFilter_displayTitle": "Відфільтровані повідомлення", + "messageFilter_displayPlaceholder": "Показувати невеликий замінник", + "messageFilter_displayHide": "Приховати повністю", + "messageFilter_displayHideHelp": "Приховані повідомлення залишаються у списку «Відфільтровані повідомлення».", + "messageFilter_rulesSection": "Ваші правила", + "messageFilter_rulesEmpty": "Правил ще немає. Додайте слово, фразу або ім’я відправника, щоб приховувати повідомлення, які їм відповідають.", + "messageFilter_addRule": "Додати правило", + "messageFilter_editRule": "Змінити правило", + "messageFilter_rulePattern": "Слово, фраза або ім’я", + "messageFilter_rulePatternHint": "напр. meshos", + "messageFilter_ruleWhere": "Де шукати", + "messageFilter_ruleFieldText": "Текст повідомлення", + "messageFilter_ruleFieldSender": "Ім’я відправника", + "messageFilter_ruleFieldBoth": "Обидва", + "messageFilter_ruleMatch": "Збіг", + "messageFilter_ruleMatchContains": "Містить", + "messageFilter_ruleMatchWholeWord": "Ціле слово", + "messageFilter_ruleMatchExact": "Точно", + "messageFilter_ruleDeleted": "Правило видалено", + "messageFilter_ruleSaved": "Правило збережено", + "messageFilter_automaticSection": "Автоматично", + "messageFilter_duplicates": "Повідомлення, що повторюються", + "messageFilter_duplicatesSubtitle": "Те саме повідомлення, надіслане знову або кількома відправниками", + "messageFilter_repeatedCharacters": "Повторювані символи", + "messageFilter_repeatedCharactersSubtitle": "Повідомлення на кшталт «aaaaaaaa» або «!!!!!!!!»", + "messageFilter_learning": "Навчання на натисканнях «Спам»", + "messageFilter_learningSubtitle": "{spam} прикладів спаму та {notSpam} прикладів не спаму", + "messageFilter_resetLearning": "Скинути навчання", + "messageFilter_resetLearningConfirm": "Забути все, чого було навчено натисканнями «Спам» і «Не спам»? Ваші правила буде збережено.", + "messageFilter_filteredMessages": "Відфільтровані повідомлення ({count})", + "messageFilter_filteredMessagesEmpty": "Нічого не відфільтровано.", + "messageFilter_ghostSingle": "Приховане повідомлення · Торкніться, щоб переглянути", + "messageFilter_ghostMany": "{count, plural, one{{count} приховане повідомлення · Торкніться, щоб переглянути} few{{count} приховані повідомлення · Торкніться, щоб переглянути} many{{count} прихованих повідомлень · Торкніться, щоб переглянути} other{{count} прихованого повідомлення · Торкніться, щоб переглянути}}", + "messageFilter_ghostSingleExpanded": "Показано приховане повідомлення · Торкніться, щоб приховати", + "messageFilter_ghostManyExpanded": "{count, plural, one{Показано {count} приховане повідомлення · Торкніться, щоб приховати} few{Показано {count} приховані повідомлення · Торкніться, щоб приховати} many{Показано {count} прихованих повідомлень · Торкніться, щоб приховати} other{Показано {count} прихованого повідомлення · Торкніться, щоб приховати}}", + "messageFilter_reasonTextRule": "Відфільтровано: збігається з «{pattern}»", + "messageFilter_reasonSenderRule": "Відфільтровано: відправник «{pattern}»", + "messageFilter_reasonRepeatedCharacters": "Відфільтровано: повторювані символи", + "messageFilter_reasonDuplicate": "Відфільтровано: повідомлення повторюється", + "messageFilter_reasonCrossSenderDuplicate": "Відфільтровано: те саме повідомлення від кількох відправників", + "messageFilter_reasonLearned": "Відфільтровано: схоже на повідомлення, які ви позначили як спам", + "messageFilter_reasonManual": "Відфільтровано: ви позначили це як спам", + "messageFilter_notSpam": "Не спам", + "messageFilter_hideAgain": "Приховати", + "messageFilter_markSpam": "Позначити як спам", + "messageFilter_markedSpam": "Позначено як спам", + "messageFilter_markedNotSpam": "Позначено як не спам", + "messageFilter_filterSender": "Фільтрувати цього відправника", + "messageFilter_filterSenderConfirm": "Приховати всі повідомлення від «{name}»?", + "messageFilter_filterLikeThis": "Фільтрувати повідомлення, схожі на це…", + "messageFilter_channelToggle": "Фільтрувати повідомлення в цьому каналі", + "messageFilter_ghostIconTooltip": "Приховано вашим фільтром повідомлень" } diff --git a/lib/l10n/app_zh.arb b/lib/l10n/app_zh.arb index 29a502be..fd788d0c 100644 --- a/lib/l10n/app_zh.arb +++ b/lib/l10n/app_zh.arb @@ -3531,5 +3531,116 @@ "themes_chatBackground": "聊天背景", "themes_chatBackgroundHelp": "显示在没有自己背景的聊天中", "themes_chatBackgroundEverywhere": "用于所有聊天", - "themes_chatBackgroundEverywhereHelp": "同时会替换单个聊天中设置的背景" + "themes_chatBackgroundEverywhereHelp": "同时会替换单个聊天中设置的背景", + "appSettings_showOnlineLinks": "显示在线地图连接", + "appSettings_showOnlineLinksSubtitle": "显示在线地图中节点之间的连接线", + "map_showOnlineLinks": "显示在线地图连接", + "messageFilter_title": "消息过滤", + "messageFilter_settingsSubtitle": "隐藏垃圾消息和重复消息", + "messageFilter_enabled": "过滤消息", + "messageFilter_enabledSubtitle": "适用于频道消息", + "messageFilter_displayTitle": "已过滤的消息", + "messageFilter_displayPlaceholder": "显示一个小占位提示", + "messageFilter_displayHide": "完全隐藏", + "messageFilter_displayHideHelp": "被隐藏的消息仍会保留在“已过滤的消息”列表中。", + "messageFilter_rulesSection": "你的规则", + "messageFilter_rulesEmpty": "还没有规则。添加一个词语、短语或发送者名称,即可隐藏匹配的消息。", + "messageFilter_addRule": "添加规则", + "messageFilter_editRule": "编辑规则", + "messageFilter_rulePattern": "词语、短语或名称", + "messageFilter_rulePatternHint": "例如 meshos", + "messageFilter_ruleWhere": "查找范围", + "messageFilter_ruleFieldText": "消息内容", + "messageFilter_ruleFieldSender": "发送者名称", + "messageFilter_ruleFieldBoth": "两者", + "messageFilter_ruleMatch": "匹配方式", + "messageFilter_ruleMatchContains": "包含", + "messageFilter_ruleMatchWholeWord": "完整词语", + "messageFilter_ruleMatchExact": "完全相同", + "messageFilter_ruleDeleted": "规则已删除", + "messageFilter_ruleSaved": "规则已保存", + "messageFilter_automaticSection": "自动", + "messageFilter_duplicates": "重复消息", + "messageFilter_duplicatesSubtitle": "重复发送的相同消息,或多个发送者发送的相同消息", + "messageFilter_repeatedCharacters": "重复字符", + "messageFilter_repeatedCharactersSubtitle": "类似“aaaaaaaa”或“!!!!!!!!”的消息", + "messageFilter_learning": "从“垃圾消息”点击中学习", + "messageFilter_learningSubtitle": "{spam} 个垃圾消息示例和 {notSpam} 个非垃圾消息示例", + "@messageFilter_learningSubtitle": { + "placeholders": { + "spam": { + "type": "int" + }, + "notSpam": { + "type": "int" + } + } + }, + "messageFilter_resetLearning": "重置学习", + "messageFilter_resetLearningConfirm": "要清除从你点击“垃圾消息”和“非垃圾消息”中学到的所有内容吗?你的规则会保留。", + "messageFilter_filteredMessages": "已过滤的消息({count})", + "@messageFilter_filteredMessages": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_filteredMessagesEmpty": "没有被过滤的消息。", + "messageFilter_ghostSingle": "已隐藏的消息 · 点击查看", + "messageFilter_ghostMany": "{count, plural, other{{count} 条已隐藏的消息 · 点击查看}}", + "@messageFilter_ghostMany": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_ghostSingleExpanded": "正在显示已隐藏的消息 · 点击隐藏", + "messageFilter_ghostManyExpanded": "{count, plural, other{正在显示 {count} 条已隐藏的消息 · 点击隐藏}}", + "@messageFilter_ghostManyExpanded": { + "placeholders": { + "count": { + "type": "int" + } + } + }, + "messageFilter_reasonTextRule": "已过滤:匹配“{pattern}”", + "@messageFilter_reasonTextRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonSenderRule": "已过滤:发送者“{pattern}”", + "@messageFilter_reasonSenderRule": { + "placeholders": { + "pattern": { + "type": "String" + } + } + }, + "messageFilter_reasonRepeatedCharacters": "已过滤:重复字符", + "messageFilter_reasonDuplicate": "已过滤:重复消息", + "messageFilter_reasonCrossSenderDuplicate": "已过滤:多个发送者发送的相同消息", + "messageFilter_reasonLearned": "已过滤:与你标记为垃圾消息的内容相似", + "messageFilter_reasonManual": "已过滤:你已将此消息标记为垃圾消息", + "messageFilter_notSpam": "非垃圾消息", + "messageFilter_hideAgain": "隐藏", + "messageFilter_markSpam": "标记为垃圾消息", + "messageFilter_markedSpam": "已标记为垃圾消息", + "messageFilter_markedNotSpam": "已标记为非垃圾消息", + "messageFilter_filterSender": "过滤此发送者", + "messageFilter_filterSenderConfirm": "要隐藏来自“{name}”的所有消息吗?", + "@messageFilter_filterSenderConfirm": { + "placeholders": { + "name": { + "type": "String" + } + } + }, + "messageFilter_filterLikeThis": "过滤类似的消息…", + "messageFilter_channelToggle": "过滤此频道中的消息", + "messageFilter_ghostIconTooltip": "已被你的消息过滤隐藏" } diff --git a/lib/main.dart b/lib/main.dart index 40756719..5b14fbad 100644 --- a/lib/main.dart +++ b/lib/main.dart @@ -21,6 +21,7 @@ import 'services/image_codec_settings_store.dart'; import 'services/received_image_blob_store_factory.dart'; import 'services/received_image_store.dart'; import 'services/storage_service.dart'; +import 'services/message_filter/message_filter_service.dart'; import 'services/message_retry_service.dart'; import 'services/path_history_service.dart'; import 'services/app_settings_service.dart'; @@ -78,6 +79,7 @@ void main() async { final translationService = TranslationService(appSettingsService); final uiViewStateService = UiViewStateService(); final timeoutPredictionService = TimeoutPredictionService(storage); + final messageFilterService = MessageFilterService(); // Load settings before anything reads them. The image stack below takes its // model registry and its "process automatically" default straight off @@ -168,6 +170,7 @@ void main() async { await receivedImageStore.load(); await uiViewStateService.initialize(); await timeoutPredictionService.initialize(); + await messageFilterService.load(); // Wire up connector with services connector.initialize( @@ -182,6 +185,7 @@ void main() async { imageCodecService: imageCodecService, imageTransport: imageTransport, receivedImageStore: receivedImageStore, + messageFilterService: messageFilterService, // ImageStreamReassembler.addChunk already forwards every outcome to the // store together with the channel index (which ImageChunkOutcome itself // does not carry), so onImageChunk would be a second, channel-blind path. @@ -216,6 +220,7 @@ void main() async { imageReassembler: imageReassembler, networkMapUploadService: networkMapUploadService, chatBackgroundService: chatBackgroundService, + messageFilterService: messageFilterService, ), ); } @@ -362,6 +367,7 @@ class MeshCoreApp extends StatefulWidget { final ImageStreamReassembler imageReassembler; final NetworkMapUploadService networkMapUploadService; final ChatBackgroundService chatBackgroundService; + final MessageFilterService messageFilterService; const MeshCoreApp({ super.key, @@ -382,6 +388,7 @@ class MeshCoreApp extends StatefulWidget { required this.imageReassembler, required this.networkMapUploadService, required this.chatBackgroundService, + required this.messageFilterService, }); @override @@ -475,6 +482,7 @@ class _MeshCoreAppState extends State with WidgetsBindingObserver { ChangeNotifierProvider.value(value: widget.receivedImageStore), ChangeNotifierProvider.value(value: widget.networkMapUploadService), ChangeNotifierProvider.value(value: widget.chatBackgroundService), + ChangeNotifierProvider.value(value: widget.messageFilterService), ], child: Consumer( builder: (context, settingsService, child) { diff --git a/lib/models/channel_message.dart b/lib/models/channel_message.dart index ccaf9170..4b66df3d 100644 --- a/lib/models/channel_message.dart +++ b/lib/models/channel_message.dart @@ -59,6 +59,12 @@ class ChannelMessage { final String? replyToText; final Map> reactions; + /// Set when the message filter hid this message (a FilterReason JSON name). + final String? filterReason; + + /// Extra context for [filterReason], e.g. the matching rule pattern. + final String? filterDetail; + ChannelMessage({ this.senderKey, required this.senderName, @@ -86,6 +92,8 @@ class ChannelMessage { this.replyToSenderName, this.replyToText, Map>? reactions, + this.filterReason, + this.filterDetail, }) : messageId = messageId ?? '${timestamp.millisecondsSinceEpoch}_${senderName.hashCode}_${text.hashCode}', @@ -97,6 +105,8 @@ class ChannelMessage { pathVariants, ); + bool get isFiltered => filterReason != null; + String? get senderKeyHex => senderKey != null ? pubKeyToHex(senderKey!) : null; @@ -125,6 +135,9 @@ class ChannelMessage { Object? translationModelId = _unset, Map>? reactions, int? channelIndex, + String? filterReason, + String? filterDetail, + bool clearFilter = false, }) { return ChannelMessage( senderKey: senderKey, @@ -161,6 +174,8 @@ class ChannelMessage { replyToSenderName: replyToSenderName ?? this.replyToSenderName, replyToText: replyToText ?? this.replyToText, reactions: reactions ?? this.reactions, + filterReason: clearFilter ? null : (filterReason ?? this.filterReason), + filterDetail: clearFilter ? null : (filterDetail ?? this.filterDetail), ); } diff --git a/lib/models/message_filter.dart b/lib/models/message_filter.dart new file mode 100644 index 00000000..850e06b6 --- /dev/null +++ b/lib/models/message_filter.dart @@ -0,0 +1,225 @@ +/// Data types for the on-device channel message filter. +/// +/// Everything here is plain data with JSON round-tripping; the matching logic +/// lives in `lib/services/message_filter/`. +library; + +/// Which part of a message a [FilterRule] looks at. +enum FilterRuleField { text, sender, both } + +/// How a [FilterRule] pattern is compared against the (normalized) target. +enum FilterRuleMatch { contains, wholeWord, exact } + +/// How filtered messages are presented in the channel transcript. +enum FilterDisplayMode { placeholder, hide } + +/// Why a message was filtered. +enum FilterReason { + senderRule, + textRule, + repeatedCharacters, + duplicate, + crossSenderDuplicate, + learned, + manual, +} + +String filterReasonToJson(FilterReason reason) => reason.name; + +FilterReason? filterReasonFromJson(String? value) { + if (value == null) return null; + for (final reason in FilterReason.values) { + if (reason.name == value) return reason; + } + return null; +} + +T _enumFromName(List values, Object? name, T fallback) { + if (name is! String) return fallback; + for (final value in values) { + if (value.name == name) return value; + } + return fallback; +} + +class FilterRule { + final String id; + final String pattern; + final FilterRuleField field; + final FilterRuleMatch match; + final bool enabled; + + const FilterRule({ + required this.id, + required this.pattern, + this.field = FilterRuleField.text, + this.match = FilterRuleMatch.contains, + this.enabled = true, + }); + + FilterRule copyWith({ + String? id, + String? pattern, + FilterRuleField? field, + FilterRuleMatch? match, + bool? enabled, + }) { + return FilterRule( + id: id ?? this.id, + pattern: pattern ?? this.pattern, + field: field ?? this.field, + match: match ?? this.match, + enabled: enabled ?? this.enabled, + ); + } + + Map toJson() => { + 'id': id, + 'pattern': pattern, + 'field': field.name, + 'match': match.name, + 'enabled': enabled, + }; + + factory FilterRule.fromJson(Map json) { + return FilterRule( + id: json['id'] as String? ?? '', + pattern: json['pattern'] as String? ?? '', + field: _enumFromName( + FilterRuleField.values, + json['field'], + FilterRuleField.text, + ), + match: _enumFromName( + FilterRuleMatch.values, + json['match'], + FilterRuleMatch.contains, + ), + enabled: json['enabled'] as bool? ?? true, + ); + } + + @override + bool operator ==(Object other) => + other is FilterRule && + other.id == id && + other.pattern == pattern && + other.field == field && + other.match == match && + other.enabled == enabled; + + @override + int get hashCode => Object.hash(id, pattern, field, match, enabled); +} + +/// A labelled training example for the learned classifier. +class FilterExample { + final String sender; + final String text; + final int addedAtMs; + + const FilterExample({ + required this.sender, + required this.text, + required this.addedAtMs, + }); + + Map toJson() => { + 'sender': sender, + 'text': text, + 'addedAtMs': addedAtMs, + }; + + factory FilterExample.fromJson(Map json) { + return FilterExample( + sender: json['sender'] as String? ?? '', + text: json['text'] as String? ?? '', + addedAtMs: (json['addedAtMs'] as num?)?.toInt() ?? 0, + ); + } +} + +class MessageFilterSettings { + final bool enabled; + final FilterDisplayMode displayMode; + final bool duplicates; + final bool repeatedCharacters; + final bool learning; + final Set excludedChannelIds; + + const MessageFilterSettings({ + this.enabled = true, + this.displayMode = FilterDisplayMode.placeholder, + this.duplicates = true, + this.repeatedCharacters = true, + this.learning = true, + this.excludedChannelIds = const {}, + }); + + static const MessageFilterSettings defaults = MessageFilterSettings(); + + MessageFilterSettings copyWith({ + bool? enabled, + FilterDisplayMode? displayMode, + bool? duplicates, + bool? repeatedCharacters, + bool? learning, + Set? excludedChannelIds, + }) { + return MessageFilterSettings( + enabled: enabled ?? this.enabled, + displayMode: displayMode ?? this.displayMode, + duplicates: duplicates ?? this.duplicates, + repeatedCharacters: repeatedCharacters ?? this.repeatedCharacters, + learning: learning ?? this.learning, + excludedChannelIds: excludedChannelIds ?? this.excludedChannelIds, + ); + } + + Map toJson() => { + 'enabled': enabled, + 'displayMode': displayMode.name, + 'duplicates': duplicates, + 'repeatedCharacters': repeatedCharacters, + 'learning': learning, + 'excludedChannelIds': excludedChannelIds.toList()..sort(), + }; + + factory MessageFilterSettings.fromJson(Map json) { + final excluded = json['excludedChannelIds']; + return MessageFilterSettings( + enabled: json['enabled'] as bool? ?? true, + displayMode: _enumFromName( + FilterDisplayMode.values, + json['displayMode'], + FilterDisplayMode.placeholder, + ), + duplicates: json['duplicates'] as bool? ?? true, + repeatedCharacters: json['repeatedCharacters'] as bool? ?? true, + learning: json['learning'] as bool? ?? true, + excludedChannelIds: excluded is List + ? excluded.whereType().toSet() + : const {}, + ); + } +} + +/// The outcome of evaluating a message that should be filtered. +class FilterVerdict { + final FilterReason reason; + final String? detail; + + const FilterVerdict({required this.reason, this.detail}); + + @override + bool operator ==(Object other) => + other is FilterVerdict && + other.reason == reason && + other.detail == detail; + + @override + int get hashCode => Object.hash(reason, detail); + + @override + String toString() => 'FilterVerdict($reason, $detail)'; +} diff --git a/lib/screens/channel_chat_screen.dart b/lib/screens/channel_chat_screen.dart index 097d0e16..227d4fbf 100644 --- a/lib/screens/channel_chat_screen.dart +++ b/lib/screens/channel_chat_screen.dart @@ -28,11 +28,13 @@ import '../l10n/l10n.dart'; import '../models/channel.dart'; import '../models/channel_message.dart'; import '../models/image_codec_support.dart' show aeicRatePointForUi; +import '../models/message_filter.dart'; import '../services/app_settings_service.dart' show AppSettingsService, ChannelNotificationMode; import '../services/chat_text_scale_service.dart'; import '../services/image_chunk_transport.dart'; import '../services/image_codec_service.dart'; +import '../services/message_filter/message_filter_service.dart'; import '../services/received_image_store.dart'; import '../services/translation_service.dart'; import '../utils/image_save.dart'; @@ -42,6 +44,8 @@ import '../widgets/received_image_message.dart'; import '../widgets/channel_notification_mode_sheet.dart'; import '../widgets/chat_day_separator.dart'; import '../widgets/empty_state.dart'; +import '../widgets/filter_rule_dialog.dart'; +import '../widgets/filtered_message_ghost.dart'; import '../widgets/chat_composer.dart'; import '../widgets/chat_send_pipeline.dart'; import '../widgets/chat_zoom_wrapper.dart'; @@ -61,6 +65,7 @@ import '../theme/mesh_theme.dart'; import '../widgets/future_timestamp_indicator.dart'; import '../widgets/mesh_ui.dart'; import 'app_settings_screen.dart'; +import 'channel_chat_transcript_grouping.dart'; import 'channel_message_path_screen.dart'; import 'map_screen.dart'; import 'region_management_screen.dart'; @@ -117,6 +122,11 @@ class _ChannelChatScreenState extends State { int _imageStoreVersion = 0; ModalRoute? _route; + /// Filtered messages the user tapped open on this screen. Session-only by + /// design: leaving the chat hides them again. + final Set _revealedFilteredIds = {}; + int _revealVersion = 0; + @override void initState() { super.initState(); @@ -144,9 +154,26 @@ class _ChannelChatScreenState extends State { _channelSkipNextBottomSnap = true; WidgetsBinding.instance.addPostFrameCallback((_) { if (!mounted) return; + // Estimate from visible list entries: filtered messages collapse + // into ghost rows (or vanish in hide mode), so raw message counts + // would undershoot. + var unreadEntries = unread; + var totalEntries = messages.length; + final layout = _transcriptLayout; + if (layout != null && layout.length > 0) { + final entryIndex = layout.ids.indexOf( + layout.entryIdFor(anchor!.messageId), + ); + if (entryIndex >= 0) { + // Entries are newest first, so the anchor has entryIndex + // newer entries below it. + unreadEntries = entryIndex + 1; + totalEntries = layout.length; + } + } _scrollController.jumpToEstimatedOffset( - unreadCount: unread, - totalMessages: messages.length, + unreadCount: unreadEntries, + totalMessages: totalEntries, onJumped: () { if (!mounted) return; _scrollToMessage(anchor!.messageId, quiet: true); @@ -179,7 +206,8 @@ class _ChannelChatScreenState extends State { var n = 0; ChannelMessage? oldest; for (final m in messages.reversed) { - if (m.isOutgoing) continue; + // Filtered messages never count as unread (see the connector). + if (m.isOutgoing || m.isFiltered) continue; n++; oldest = m; if (n >= unreadCount) break; @@ -261,7 +289,10 @@ class _ChannelChatScreenState extends State { } Future _scrollToMessage(String messageId, {bool quiet = false}) async { - final key = _messageKeys[messageId]; + // A message hidden by the filter is represented by its ghost row (or the + // nearest visible row in hide mode). + final key = + _messageKeys[_transcriptLayout?.entryIdFor(messageId) ?? messageId]; if (key == null) { // The auto unread-jump can resolve a frame after navigating away; // a deactivated context can't host a snackbar. @@ -447,11 +478,20 @@ class _ChannelChatScreenState extends State { ); } else if (value == 'clearChat') { _confirmClearChat(); + } else if (value == 'messageFilter') { + _toggleChannelFiltering(); } }, // Region lives here (and on a tap of the title) so the channel // name keeps its room in the app bar. itemBuilder: (context) => [ + if (_messageFilter case final filter? + when filter.settings.enabled) + CheckedPopupMenuItem( + value: 'messageFilter', + checked: filter.isChannelFiltered(_messageFilterChannelId), + child: Text(context.l10n.messageFilter_channelToggle), + ), PopupMenuItem( value: 'region', child: Row( @@ -508,7 +548,10 @@ class _ChannelChatScreenState extends State { final messages = connector.getChannelMessages( widget.channel, ); - final newest = messages.isEmpty ? null : messages.last; + // A filtered message must not trigger holiday effects. + final newest = connector.latestVisibleChannelMessage( + widget.channel, + ); _holidayWatcher.onNewest( context, id: newest?.messageId, @@ -586,9 +629,10 @@ class _ChannelChatScreenState extends State { } else { messageKey = GlobalKey(); } + final dividerId = _unreadDividerMessageId; final isUnreadAnchor = - _unreadDividerMessageId != null && - row.id == _unreadDividerMessageId; + dividerId != null && + row.id == layout.entryIdFor(dividerId); return Container( key: messageKey, child: Builder( @@ -598,16 +642,30 @@ class _ChannelChatScreenState extends State { (service) => service.scale, ); final message = row.message; - final bubble = message != null - ? _buildMessageBubble( - message, - textScale, - urlImagesEnabled, - ) - : _buildImageBubble( - row.image!, - textScale, - ); + final ghost = row.ghost; + final Widget bubble; + if (ghost != null) { + bubble = _buildFilteredGhost( + ghost, + textScale, + expanded: row.ghostExpanded, + urlImagesEnabled: urlImagesEnabled, + ); + } else if (message != null) { + bubble = _buildMessageBubble( + message, + textScale, + urlImagesEnabled, + showFilterBanner: + layout.filterActive && + message.isFiltered, + ); + } else { + bubble = _buildImageBubble( + row.image!, + textScale, + ); + } final startsDay = index == rowCount - 1 || !isSameChatDay( @@ -658,7 +716,7 @@ class _ChannelChatScreenState extends State { var found = false; for (final m in messages) { if (m.messageId == message.messageId) found = true; - if (found && !m.isOutgoing) count++; + if (found && !m.isOutgoing && !m.isFiltered) count++; } connector.setChannelUnreadCount(widget.channel.index, count); } @@ -666,8 +724,9 @@ class _ChannelChatScreenState extends State { Widget _buildMessageBubble( ChannelMessage message, double textScale, - bool urlImagesEnabled, - ) { + bool urlImagesEnabled, { + bool showFilterBanner = false, + }) { final settingsService = context.watch(); final publicIpfsGateway = settingsService.settings.publicIpfsGateway; final enableTracing = settingsService.settings.enableMessageTracing; @@ -781,6 +840,18 @@ class _ChannelChatScreenState extends State { ), if (gifId == null) const SizedBox(height: 2), ], + if (showFilterBanner) + FilteredMessageBanner( + reason: messageFilterReasonLabel( + context.l10n, + message.filterReason, + message.filterDetail, + ), + color: textColor, + textScale: textScale, + onNotSpam: () => _markNotSpam(message), + onHide: () => _hideFilteredMessage(message), + ), if (message.replyToMessageId != null) ...[ _buildReplyPreview(message, textScale), const SizedBox(height: 8), @@ -1153,11 +1224,52 @@ class _ChannelChatScreenState extends State { final connector = context.read(); final isOwnNode = message.replyToSenderName == connector.selfName; final colorScheme = Theme.of(context).colorScheme; - final contentPreview = _buildReplyContent( - message.replyToText ?? '', - textScale, - color: colorScheme.onSurface.withValues(alpha: 0.7), - ); + final previewColor = colorScheme.onSurface.withValues(alpha: 0.7); + // The quoted text was copied when the reply arrived; if the quoted message + // is hidden by the filter, don't spell it out until it is revealed. + final quotedId = message.replyToMessageId; + final quoted = quotedId == null + ? null + : connector + .getChannelMessages(widget.channel) + .where((m) => m.messageId == quotedId) + .lastOrNull; + final concealed = + quoted != null && + isReplyPreviewConcealed( + quotedIsFiltered: quoted.isFiltered, + filterActive: + _messageFilter?.isChannelFiltered(_messageFilterChannelId) ?? + false, + quotedRevealed: _revealedFilteredIds.contains(quoted.messageId), + ); + final contentPreview = concealed + ? Row( + mainAxisSize: MainAxisSize.min, + children: [ + Icon( + Icons.visibility_off_outlined, + size: 16 * textScale, + color: previewColor, + ), + const SizedBox(width: 6), + Flexible( + child: Text( + context.l10n.messageFilter_ghostSingle, + style: TextStyle( + fontSize: 13 * textScale, + fontStyle: FontStyle.italic, + color: previewColor, + ), + ), + ), + ], + ) + : _buildReplyContent( + message.replyToText ?? '', + textScale, + color: previewColor, + ); return GestureDetector( onTap: () => _scrollToMessage(message.replyToMessageId!), @@ -1701,9 +1813,32 @@ class _ChannelChatScreenState extends State { store?.addListener(_onImageStoreChanged); _imageStoreVersion++; } + MessageFilterService? filter; + try { + filter = context.watch(); + } on ProviderNotFoundException { + filter = null; + } + final displayMode = + filter?.settings.displayMode ?? FilterDisplayMode.placeholder; + final filterActive = + filter?.isChannelFiltered(_messageFilterChannelId) ?? true; + // Spam / Not spam replace a message in place (same list, length and + // ends), so the memo also keys on which messages are filtered. + final filterVersion = Object.hash( + displayMode, + filterActive, + _revealVersion, + _filteredMessagesSignature(messages), + ); final cached = _transcriptLayout; if (cached != null && - cached.matches(messages, _imageStoreVersion, widget.channel.index)) { + cached.matches( + messages, + _imageStoreVersion, + widget.channel.index, + filterVersion, + )) { return cached; } final images = store == null @@ -1714,6 +1849,10 @@ class _ChannelChatScreenState extends State { images: images, imageVersion: _imageStoreVersion, channelIndex: widget.channel.index, + filterVersion: filterVersion, + displayMode: displayMode, + filterActive: filterActive, + revealedIds: _revealedFilteredIds, ); // Prune stale keys (deleted/cleared messages) to avoid unbounded growth. final liveIds = layout.ids.toSet(); @@ -1724,6 +1863,19 @@ class _ChannelChatScreenState extends State { void _onImageStoreChanged() => _imageStoreVersion++; + /// Cheap fingerprint of which messages are filtered, so the layout memo + /// notices a message being marked spam or not spam in place. + static int _filteredMessagesSignature(List messages) { + var hash = 0; + var count = 0; + for (final m in messages) { + if (!m.isFiltered) continue; + count++; + hash = Object.hash(hash, m.messageId); + } + return Object.hash(count, hash); + } + /// Bubble for one AEIC image, following the GIF-message precedent: minimal /// chrome, the renderer owns every state (receiving / decoding / failed) and /// the mandatory AI-reconstruction label. @@ -2286,6 +2438,14 @@ class _ChannelChatScreenState extends State { isOutgoing: message.isOutgoing, ) && (message.translatedText?.trim().isEmpty ?? true); + // Filter actions apply to incoming messages in a channel the filter + // covers; structured payloads (GIFs, markers) are never filtered. + final filter = _messageFilter; + final showFilterActions = + !message.isOutgoing && + filter != null && + filter.isChannelFiltered(_messageFilterChannelId) && + (message.isFiltered || !_isStructuredPayload(message.text)); showMeshSheet( context, @@ -2377,6 +2537,44 @@ class _ChannelChatScreenState extends State { _markAsUnread(message); }, ), + if (showFilterActions) ...[ + const Divider(height: 1), + if (message.isFiltered) + ListTile( + leading: const Icon(Icons.visibility_outlined), + title: Text(context.l10n.messageFilter_notSpam), + onTap: () { + Navigator.pop(sheetContext); + _markNotSpam(message); + }, + ) + else + ListTile( + leading: const Icon(Icons.visibility_off_outlined), + title: Text(context.l10n.messageFilter_markSpam), + onTap: () { + Navigator.pop(sheetContext); + _markSpam(message); + }, + ), + if (message.senderName.trim().isNotEmpty) + ListTile( + leading: const Icon(Icons.person_off_outlined), + title: Text(context.l10n.messageFilter_filterSender), + onTap: () { + Navigator.pop(sheetContext); + _filterSender(message.senderName); + }, + ), + ListTile( + leading: const Icon(Icons.filter_alt_outlined), + title: Text(context.l10n.messageFilter_filterLikeThis), + onTap: () { + Navigator.pop(sheetContext); + _filterMessagesLike(message); + }, + ), + ], const Divider(height: 1), ListTile( leading: Icon( @@ -2400,6 +2598,172 @@ class _ChannelChatScreenState extends State { ); } + // ---- message filter ------------------------------------------------------- + + /// The message filter, or null when it is not registered (screen tests). + MessageFilterService? get _messageFilter { + try { + return context.read(); + } on ProviderNotFoundException { + return null; + } + } + + String get _messageFilterChannelId => + MeshCoreConnector.messageFilterChannelId(widget.channel); + + /// GIFs and other structured payloads (same test as the connector's + /// outbound check), which the filter never looks at. + static bool _isStructuredPayload(String text) { + final trimmed = text.trimLeft(); + return trimmed.startsWith('g:') || trimmed.startsWith('m:'); + } + + void _setRevealed(Iterable ids, {required bool revealed}) { + setState(() { + if (revealed) { + _revealedFilteredIds.addAll(ids); + } else { + _revealedFilteredIds.removeAll(ids); + } + _revealVersion++; + }); + } + + /// "Hide" on a revealed message collapses its whole run back into one + /// ghost row, not just that message. + void _hideFilteredMessage(ChannelMessage message) { + final layout = _transcriptLayout; + final messages = context.read().getChannelMessages( + widget.channel, + ); + final ids = layout == null + ? [message.messageId] + : layout.revealedRunIdsFor(message.messageId, messages); + _setRevealed(ids, revealed: false); + } + + Future _markSpam(ChannelMessage message) async { + final connector = context.read(); + // Collapse it straight away, even if it had been revealed before. + _setRevealed([message.messageId], revealed: false); + await connector.markChannelMessageSpam(widget.channel, message); + if (!mounted) return; + showDismissibleSnackBar( + context, + content: Text(context.l10n.messageFilter_markedSpam), + ); + } + + Future _markNotSpam(ChannelMessage message) async { + final connector = context.read(); + _setRevealed([message.messageId], revealed: false); + await connector.markChannelMessageNotSpam(widget.channel, message); + if (!mounted) return; + showDismissibleSnackBar( + context, + content: Text(context.l10n.messageFilter_markedNotSpam), + ); + } + + Future _filterSender(String senderName) async { + final filter = _messageFilter; + if (filter == null) return; + final confirmed = await showDialog( + context: context, + builder: (dialogContext) => AlertDialog( + title: Text(dialogContext.l10n.messageFilter_filterSender), + content: Text( + dialogContext.l10n.messageFilter_filterSenderConfirm(senderName), + ), + actions: [ + TextButton( + onPressed: () => Navigator.pop(dialogContext, false), + child: Text(dialogContext.l10n.common_cancel), + ), + FilledButton( + onPressed: () => Navigator.pop(dialogContext, true), + child: Text(dialogContext.l10n.messageFilter_filterSender), + ), + ], + ), + ); + if (confirmed != true) return; + await filter.addRule( + FilterRule( + id: MessageFilterService.newRuleId(), + pattern: senderName, + field: FilterRuleField.sender, + match: FilterRuleMatch.exact, + ), + ); + if (!mounted) return; + showDismissibleSnackBar( + context, + content: Text(context.l10n.messageFilter_ruleSaved), + ); + } + + Future _filterMessagesLike(ChannelMessage message) async { + final filter = _messageFilter; + if (filter == null) return; + final rule = await showFilterRuleDialog( + context, + initialPattern: message.text, + initialField: FilterRuleField.text, + ); + if (rule == null) return; + await filter.addRule(rule); + if (!mounted) return; + showDismissibleSnackBar( + context, + content: Text(context.l10n.messageFilter_ruleSaved), + ); + } + + Future _toggleChannelFiltering() async { + final filter = _messageFilter; + if (filter == null) return; + final channelId = _messageFilterChannelId; + await filter.setChannelExcluded( + channelId, + filter.isChannelFiltered(channelId), + ); + } + + /// One entry for a run of hidden messages (newest first): a ghost header + /// that animates the run's messages open and closed underneath it. Opening + /// lasts for this visit to the chat. + Widget _buildFilteredGhost( + List run, + double textScale, { + required bool expanded, + required bool urlImagesEnabled, + }) { + final newest = run.first; + return FilteredMessageRun( + count: run.length, + expanded: expanded, + buildMessages: (context) => [ + for (final message in run.reversed) + _buildMessageBubble( + message, + textScale, + urlImagesEnabled, + showFilterBanner: true, + ), + ], + reason: messageFilterReasonLabel( + context.l10n, + newest.filterReason, + newest.filterDetail, + ), + textScale: textScale, + onToggle: () => + _setRevealed([for (final m in run) m.messageId], revealed: !expanded), + ); + } + void _showEmojiPicker(ChannelMessage message) { showMeshSheet( context, @@ -2822,7 +3186,7 @@ class _SwipeReplyBubbleState extends State<_SwipeReplyBubble> { /// One row of the channel transcript. /// -/// Exactly one of [message] / [image] is non-null. Images cannot be +/// Exactly one of [message] / [image] / [ghost] is non-null. Images cannot be /// `ChannelMessage`s: they arrive as GRP_DATA chunks with no text frame behind /// them, are keyed on (sender prefix, img id, channel) rather than a message id, /// and are persisted by [ReceivedImageStore] instead of the channel message @@ -2832,15 +3196,34 @@ class _ChannelChatRow { final ChannelMessage? message; final ReceivedImageEntry? image; - const _ChannelChatRow({this.message, this.image}); + /// A run of consecutive messages hidden by the message filter, newest + /// first, shown as one ghost row. + final List? ghost; + + /// [ghost] is a revealed run: its messages are shown under the header. + final bool ghostExpanded; + + const _ChannelChatRow({ + this.message, + this.image, + this.ghost, + this.ghostExpanded = false, + }); /// Local arrival time, used for ordering and day separators so a sender - /// clock running ahead cannot pin a row to the bottom (#584). - DateTime get receivedAt => message?.receivedAt ?? image!.firstSeen; + /// clock running ahead cannot pin a row to the bottom (#584). A ghost run + /// never spans two days, so its newest member stands for it. + DateTime get receivedAt => + message?.receivedAt ?? ghost?.first.receivedAt ?? image!.firstSeen; /// Stable identity for the scroll-to-message [GlobalKey] map. The `aeic:` - /// prefix keeps a stream id from ever colliding with a message id. - String get id => message?.messageId ?? 'aeic:${image!.streamId}'; + /// and `ghost:` prefixes keep these from ever colliding with a message id. + String get id { + final run = ghost; + // Same id open or closed, so the run keeps its State and can animate. + if (run != null) return 'ghost:${run.first.messageId}'; + return message?.messageId ?? 'aeic:${image!.streamId}'; + } } /// Memoised ordering of a channel transcript, newest first. @@ -2848,6 +3231,10 @@ class _ChannelChatRow { /// Rows hold positions, not message objects: the connector replaces messages /// in place (status, repeats, reactions) without changing their order or id, /// so [rowAt] always reads the current object from the live list. +/// +/// Messages hidden by the message filter are grouped by [groupFilteredRows]: +/// each visible entry is one row, or one ghost standing in for a run of +/// hidden messages (none at all in hide mode). class _TranscriptLayout { final List _source; final int _sourceLength; @@ -2855,14 +3242,26 @@ class _TranscriptLayout { final String? _lastId; final int _imageVersion; final int _channelIndex; + final int _filterVersion; /// Newest first. `>= 0` is a message index; `< 0` is image `-(i + 1)`. final List _order; final List _images; - /// Row ids, aligned with [_order]. + /// Visible entries, newest first; their rows index into [_order]. + final List _entries; + + /// Whether filtered messages are being hidden in this channel. When false + /// they render as ordinary bubbles, without the filter banner. + final bool filterActive; + + /// Entry ids, aligned with the visible entries. final List ids; + /// Row id (message id) -> id of the entry that shows it, for rows that are + /// not entries themselves (inside a ghost, or dropped in hide mode). + final Map _entryIdByRowId; + /// Two messages can collide on messageId (same ms + name/text hash). Only /// the first occurrence owns the shared GlobalKey used for /// scroll-to-message; duplicates get a local key so no two widgets share @@ -2876,9 +3275,13 @@ class _TranscriptLayout { this._lastId, this._imageVersion, this._channelIndex, + this._filterVersion, this._order, this._images, + this._entries, + this.filterActive, this.ids, + this._entryIdByRowId, this.keyedIndices, ); @@ -2887,6 +3290,10 @@ class _TranscriptLayout { required List images, required int imageVersion, required int channelIndex, + required int filterVersion, + required FilterDisplayMode displayMode, + required bool filterActive, + required Set revealedIds, }) { DateTime timeOf(int code) => code >= 0 ? messages[code].receivedAt : images[-code - 1].firstSeen; @@ -2901,12 +3308,38 @@ class _TranscriptLayout { // the reversed ListView. mergeSort(order, compare: (a, b) => timeOf(a).compareTo(timeOf(b))); final reversed = order.reversed.toList(growable: false); - final ids = [ + final rowInfos = [ for (final code in reversed) code >= 0 - ? messages[code].messageId - : 'aeic:${images[-code - 1].streamId}', + ? TranscriptRowInfo( + id: messages[code].messageId, + receivedAt: messages[code].receivedAt, + isFiltered: messages[code].isFiltered, + ) + : TranscriptRowInfo( + id: 'aeic:${images[-code - 1].streamId}', + receivedAt: images[-code - 1].firstSeen, + isImage: true, + ), ]; + final entries = groupFilteredRows( + rowInfos, + mode: displayMode, + revealedIds: revealedIds, + filterActive: filterActive, + sameDay: isSameChatDay, + ); + final ids = [for (final entry in entries) entry.id]; + final entryIdByRowId = {}; + final entryByRow = entryIndexByRow(entries, rowInfos.length); + for (var row = 0; row < rowInfos.length; row++) { + final entry = entryByRow[row]; + if (entry == null) continue; + final rowId = rowInfos[row].id; + final entryId = ids[entry]; + // First occurrence wins, matching the GlobalKey ownership below. + if (rowId != entryId) entryIdByRowId.putIfAbsent(rowId, () => entryId); + } final seen = {}; final keyed = {}; for (var i = 0; i < ids.length; i++) { @@ -2919,26 +3352,65 @@ class _TranscriptLayout { messages.isEmpty ? null : messages.last.messageId, imageVersion, channelIndex, + filterVersion, reversed, images, + entries, + filterActive, ids, + entryIdByRowId, keyed, ); } - int get length => _order.length; + int get length => _entries.length; - bool matches(List messages, int imageVersion, int channel) { + bool matches( + List messages, + int imageVersion, + int channel, + int filterVersion, + ) { return identical(messages, _source) && messages.length == _sourceLength && imageVersion == _imageVersion && channel == _channelIndex && + filterVersion == _filterVersion && (messages.isEmpty ? null : messages.first.messageId) == _firstId && (messages.isEmpty ? null : messages.last.messageId) == _lastId; } + /// Id of the visible entry that shows the row with [rowId]: the row itself, + /// its ghost, or (hide mode) the nearest visible row. + String entryIdFor(String rowId) => _entryIdByRowId[rowId] ?? rowId; + + /// Ids of every message in the revealed run containing [messageId], so + /// "Hide" on one of them collapses the whole run; just [messageId] when it + /// is not part of a revealed run. + List revealedRunIdsFor( + String messageId, + List messages, + ) { + for (final entry in _entries) { + if (!entry.expanded) continue; + final ids = [ + for (final row in entry.rows) + if (_order[row] >= 0) messages[_order[row]].messageId, + ]; + if (ids.contains(messageId)) return ids; + } + return [messageId]; + } + _ChannelChatRow rowAt(int index, List messages) { - final code = _order[index]; + final entry = _entries[index]; + if (entry.isGhost) { + return _ChannelChatRow( + ghost: [for (final row in entry.rows) messages[_order[row]]], + ghostExpanded: entry.expanded, + ); + } + final code = _order[entry.row]; return code >= 0 ? _ChannelChatRow(message: messages[code]) : _ChannelChatRow(image: _images[-code - 1]); diff --git a/lib/screens/channel_chat_transcript_grouping.dart b/lib/screens/channel_chat_transcript_grouping.dart new file mode 100644 index 00000000..33847835 --- /dev/null +++ b/lib/screens/channel_chat_transcript_grouping.dart @@ -0,0 +1,198 @@ +/// Pure grouping of a channel transcript into visible entries, collapsing +/// messages hidden by the message filter. +/// +/// Kept free of widgets and connector state so the rules (runs, hide mode, +/// revealed messages, images, anchors) can be unit tested directly. +library; + +import 'package:flutter/foundation.dart' show immutable, listEquals; + +import '../models/message_filter.dart'; + +/// What the grouping needs to know about one transcript row. +@immutable +class TranscriptRowInfo { + /// Row identity: a message id, or an `aeic:` image stream id. + final String id; + + /// The message filter tagged this row. + final bool isFiltered; + + /// Image rows are never filtered, whatever [isFiltered] says. + final bool isImage; + + /// Local arrival time; a ghost run never spans two chat days when the + /// grouping is given a `sameDay` test. + final DateTime receivedAt; + + const TranscriptRowInfo({ + required this.id, + required this.receivedAt, + this.isFiltered = false, + this.isImage = false, + }); +} + +/// One visible entry of the transcript: a single row, or a ghost standing in +/// for a run of consecutive hidden rows. A revealed run stays ONE entry (with +/// [expanded] set) so its id never changes and the chat can animate it open +/// and closed in place. +@immutable +class TranscriptEntry { + /// Indices into the row list given to [groupFilteredRows], in the same + /// (newest-first) order. Exactly one for a plain row. + final List rows; + + /// Whether this entry is a run of filtered messages. + final bool isGhost; + + /// For a ghost: the run is revealed (its messages are shown under the + /// "tap to hide" header). + final bool expanded; + + /// Stable identity: the row id, or `ghost:` for a run in + /// either state. + final String id; + + const TranscriptEntry._(this.rows, this.isGhost, this.id, this.expanded); + + factory TranscriptEntry.row(int row, String id) => + TranscriptEntry._(List.unmodifiable([row]), false, id, false); + + factory TranscriptEntry.ghost( + List rows, + String newestId, { + bool expanded = false, + }) => TranscriptEntry._( + List.unmodifiable(rows), + true, + 'ghost:$newestId', + expanded, + ); + + /// The single row of a non-ghost entry. + int get row => rows.first; + + @override + bool operator ==(Object other) => + other is TranscriptEntry && + other.isGhost == isGhost && + other.expanded == expanded && + other.id == id && + listEquals(other.rows, rows); + + @override + int get hashCode => Object.hash(isGhost, expanded, id, Object.hashAll(rows)); + + @override + String toString() => !isGhost + ? 'TranscriptEntry.row($row)' + : 'TranscriptEntry.ghost($rows${expanded ? ', expanded' : ''})'; +} + +/// Groups [rows] (newest first, as displayed by the reversed chat list) into +/// visible entries. +/// +/// A row is filtered-out when [filterActive] is true and it is a filtered +/// message (not an image). With [FilterDisplayMode.hide] such rows are dropped +/// unless their id is in [revealedIds]. With [FilterDisplayMode.placeholder] +/// consecutive filtered rows form runs, split wherever the revealed state +/// changes (and, when [sameDay] is given, where the chat day changes): +/// each run becomes one [TranscriptEntry.ghost], `expanded` when revealed. +/// Its id depends only on the newest member, so revealing or hiding a run +/// keeps the same entry (and lets the UI animate between the two states). +List groupFilteredRows( + List rows, { + required FilterDisplayMode mode, + Set revealedIds = const {}, + bool filterActive = true, + bool Function(DateTime a, DateTime b)? sameDay, +}) { + bool isFilteredRow(TranscriptRowInfo row) => + filterActive && row.isFiltered && !row.isImage; + + final entries = []; + var run = []; + var runRevealed = false; + + void flushRun() { + if (run.isEmpty) return; + entries.add( + TranscriptEntry.ghost(run, rows[run.first].id, expanded: runRevealed), + ); + run = []; + } + + for (var i = 0; i < rows.length; i++) { + final row = rows[i]; + if (!isFilteredRow(row)) { + flushRun(); + entries.add(TranscriptEntry.row(i, row.id)); + continue; + } + final revealed = revealedIds.contains(row.id); + if (mode == FilterDisplayMode.hide) { + if (revealed) entries.add(TranscriptEntry.row(i, row.id)); + continue; + } + if (run.isNotEmpty && + (revealed != runRevealed || + (sameDay != null && + !sameDay(rows[run.last].receivedAt, row.receivedAt)))) { + flushRun(); + } + if (run.isEmpty) runRevealed = revealed; + run.add(i); + } + flushRun(); + return entries; +} + +/// Maps every row index to the index of the entry that represents it on +/// screen, for scroll targets and the unread divider. +/// +/// A row inside a ghost (collapsed or expanded) maps to that ghost. A row +/// dropped in hide mode maps +/// to the nearest newer visible entry (the one shown just below it), or, when +/// nothing newer is visible, the nearest older one. Rows map to nothing only +/// when [entries] is empty. +Map entryIndexByRow(List entries, int rowCount) { + final result = {}; + for (var e = 0; e < entries.length; e++) { + for (final row in entries[e].rows) { + result[row] = e; + } + } + if (entries.isEmpty || result.length == rowCount) return result; + // Rows are newest first, so the newer neighbour has the smaller index. + int? newerEntry; + for (var row = 0; row < rowCount; row++) { + final own = result[row]; + if (own != null) { + newerEntry = own; + } else if (newerEntry != null) { + result[row] = newerEntry; + } + } + int? olderEntry; + for (var row = rowCount - 1; row >= 0; row--) { + final own = result[row]; + if (own != null) { + olderEntry = own; + } else if (olderEntry != null) { + result[row] = olderEntry; + } + } + return result; +} + +/// Whether a reply's quoted preview must be concealed: the quoted message +/// ([quotedIsFiltered]) was hidden by the message filter, filtering is on for +/// the channel ([filterActive]) and the user has not revealed it +/// ([quotedRevealed]). Replies copy the quoted text when they arrive, so +/// without this a reply would show hidden spam in an ordinary bubble. +bool isReplyPreviewConcealed({ + required bool quotedIsFiltered, + required bool filterActive, + required bool quotedRevealed, +}) => filterActive && quotedIsFiltered && !quotedRevealed; diff --git a/lib/screens/channels_screen.dart b/lib/screens/channels_screen.dart index df298299..ab768966 100644 --- a/lib/screens/channels_screen.dart +++ b/lib/screens/channels_screen.dart @@ -12,6 +12,7 @@ import '../connector/meshcore_connector.dart'; import '../l10n/l10n.dart'; import '../services/app_settings_service.dart' show AppSettingsService, ChannelNotificationMode; +import '../services/message_filter/message_filter_service.dart'; import '../services/ui_view_state_service.dart'; import '../models/channel.dart'; import '../models/community.dart'; @@ -102,6 +103,12 @@ class _ChannelsScreenState extends State Widget build(BuildContext context) { final connector = context.watch(); final viewState = context.watch(); + // Previews and "latest" sorting depend on per-channel filter settings. + try { + context.watch(); + } on ProviderNotFoundException { + // No message filter in this tree (tests); previews ignore it. + } // Auto-navigate back to scanner if disconnected if (!checkConnectionAndNavigate(connector)) { @@ -426,9 +433,9 @@ class _ChannelsScreenState extends State iconColor = MeshPalette.blue; } - // Last message preview - final messages = connector.getChannelMessages(channel); - final lastMessage = messages.isNotEmpty ? messages.last : null; + // Last message preview. Messages hidden by the message filter never + // become the preview. + final lastMessage = connector.latestVisibleChannelMessage(channel); final lastMessageText = lastMessage?.text ?? ''; final lastPreview = lastMessageText.isNotEmpty && @@ -774,14 +781,13 @@ class _ChannelsScreenState extends State break; case ChannelSortOption.latestMessages: filtered.sort((a, b) { - final aMessages = connector.getChannelMessages(a); - final bMessages = connector.getChannelMessages(b); - final aLast = aMessages.isEmpty - ? DateTime(1970) - : aMessages.last.timestamp; - final bLast = bMessages.isEmpty - ? DateTime(1970) - : bMessages.last.timestamp; + // Filtered messages don't bump a channel, matching the preview. + final aLast = + connector.latestVisibleChannelMessage(a)?.timestamp ?? + DateTime(1970); + final bLast = + connector.latestVisibleChannelMessage(b)?.timestamp ?? + DateTime(1970); final timeCompare = bLast.compareTo(aLast); if (timeCompare != 0) return timeCompare; return compareByName(a, b); diff --git a/lib/screens/filtered_messages_screen.dart b/lib/screens/filtered_messages_screen.dart new file mode 100644 index 00000000..aa711985 --- /dev/null +++ b/lib/screens/filtered_messages_screen.dart @@ -0,0 +1,256 @@ +import 'package:flutter/material.dart'; +import 'package:provider/provider.dart'; + +import '../connector/meshcore_connector.dart'; +import '../helpers/snack_bar_builder.dart'; +import '../l10n/l10n.dart'; +import '../models/channel.dart'; +import '../models/channel_message.dart'; +import '../models/message_filter.dart'; +import '../widgets/filtered_message_ghost.dart'; +import '../widgets/adaptive_app_bar_title.dart'; +import '../widgets/empty_state.dart'; +import '../widgets/mesh_ui.dart'; + +/// Recent filtered channel messages across all channels, newest first. +/// +/// Message text and sender stay hidden until the row is tapped, so the list +/// can be opened without being shown the spam itself. "Not spam" puts a +/// message back in its channel and teaches the filter. +class FilteredMessagesScreen extends StatefulWidget { + const FilteredMessagesScreen({super.key}); + + @override + State createState() => _FilteredMessagesScreenState(); +} + +/// Identity of a row in the Filtered messages list (widget key and reveal +/// state). Message ids do not include the channel and can collide across +/// channels, so they are scoped by the channel's filter id. +String filteredMessageRowId(Channel channel, ChannelMessage message) => + '${MeshCoreConnector.messageFilterChannelId(channel)}|${message.messageId}'; + +class _FilteredMessagesScreenState extends State { + final Set _revealed = {}; + + static String _rowId(Channel channel, ChannelMessage message) => + filteredMessageRowId(channel, message); + + void _toggle(String rowId) { + setState(() { + if (!_revealed.remove(rowId)) _revealed.add(rowId); + }); + } + + Future _markNotSpam(Channel channel, ChannelMessage message) async { + final connector = context.read(); + final text = context.l10n.messageFilter_markedNotSpam; + await connector.markChannelMessageNotSpam(channel, message); + if (!mounted) return; + _revealed.remove(_rowId(channel, message)); + showDismissibleSnackBar( + context, + content: Text(text), + duration: const Duration(seconds: 2), + ); + } + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final connector = context.watch(); + final entries = connector.recentFilteredChannelMessages(); + + return Scaffold( + appBar: AppBar( + title: AdaptiveAppBarTitle(l10n.messageFilter_displayTitle), + centerTitle: true, + ), + body: SafeArea( + top: false, + child: entries.isEmpty + ? EmptyState( + icon: Icons.filter_alt_outlined, + title: l10n.messageFilter_filteredMessagesEmpty, + ) + : ListView.builder( + padding: const EdgeInsets.fromLTRB(0, 8, 0, 24), + itemCount: entries.length, + itemBuilder: (context, index) { + final (channel, message) = entries[index]; + final id = _rowId(channel, message); + return _FilteredMessageCard( + key: ValueKey('filtered_$id'), + channel: channel, + message: message, + revealed: _revealed.contains(id), + onToggle: () => _toggle(id), + onNotSpam: () => _markNotSpam(channel, message), + ); + }, + ), + ), + ); + } +} + +class _FilteredMessageCard extends StatelessWidget { + final Channel channel; + final ChannelMessage message; + final bool revealed; + final VoidCallback onToggle; + final VoidCallback onNotSpam; + + const _FilteredMessageCard({ + super.key, + required this.channel, + required this.message, + required this.revealed, + required this.onToggle, + required this.onNotSpam, + }); + + String _relativeTime(BuildContext context, DateTime t) { + final diff = DateTime.now().difference(t); + final l10n = context.l10n; + if (diff.inMinutes < 1) return l10n.channels_timeNow; + if (diff.inMinutes < 60) return l10n.channels_timeMinutes(diff.inMinutes); + if (diff.inHours < 24) return l10n.channels_timeHours(diff.inHours); + return l10n.channels_timeDays(diff.inDays); + } + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final theme = Theme.of(context); + final scheme = theme.colorScheme; + final channelLabel = channel.name.isEmpty + ? l10n.channels_channelIndex(channel.index) + : channel.name; + final secondary = theme.textTheme.bodyMedium?.copyWith( + color: scheme.onSurfaceVariant, + ); + + return MeshCard( + onTap: onToggle, + padding: const EdgeInsets.fromLTRB(16, 12, 8, 4), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Padding( + padding: const EdgeInsetsDirectional.only(end: 8), + child: Row( + children: [ + Expanded( + child: Text( + channelLabel, + maxLines: 1, + overflow: TextOverflow.ellipsis, + style: theme.textTheme.bodyLarge?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + ), + const SizedBox(width: 8), + Text( + _relativeTime(context, message.receivedAt), + style: secondary, + ), + ], + ), + ), + const SizedBox(height: 4), + Padding( + padding: const EdgeInsetsDirectional.only(end: 8), + child: Text( + messageFilterReasonText(context, message, revealed: revealed), + style: secondary, + ), + ), + const SizedBox(height: 8), + AnimatedSize( + duration: const Duration(milliseconds: 150), + alignment: AlignmentDirectional.topStart, + child: Padding( + padding: const EdgeInsetsDirectional.only(end: 8), + child: revealed + ? Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + message.senderName, + style: theme.textTheme.bodyMedium?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + const SizedBox(height: 2), + SelectableText( + message.text, + style: theme.textTheme.bodyLarge, + ), + ], + ) + : Row( + children: [ + Icon( + Icons.visibility_outlined, + size: 20, + color: scheme.onSurfaceVariant, + ), + const SizedBox(width: 8), + Expanded( + child: Text( + l10n.messageFilter_ghostSingle, + style: secondary, + ), + ), + ], + ), + ), + ), + Align( + alignment: AlignmentDirectional.centerEnd, + child: TextButton.icon( + style: TextButton.styleFrom(minimumSize: const Size(0, 48)), + onPressed: onNotSpam, + icon: const Icon(Icons.check_circle_outline, size: 22), + label: Text(l10n.messageFilter_notSpam), + ), + ), + ], + ), + ); + } +} + +/// The "Filtered: …" line explaining why [message] was hidden. +/// +/// Until the card is [revealed] the rule pattern is shortened like the chat +/// placeholder's (a rule made with "Filter messages like this…" can be the +/// whole spam message); once the message itself is shown, the full pattern is. +String messageFilterReasonText( + BuildContext context, + ChannelMessage message, { + bool revealed = false, +}) { + final l10n = context.l10n; + if (!revealed) { + return messageFilterReasonLabel( + l10n, + message.filterReason, + message.filterDetail, + ); + } + final detail = message.filterDetail ?? ''; + return switch (filterReasonFromJson(message.filterReason)) { + FilterReason.senderRule => l10n.messageFilter_reasonSenderRule(detail), + FilterReason.textRule => l10n.messageFilter_reasonTextRule(detail), + FilterReason.repeatedCharacters => + l10n.messageFilter_reasonRepeatedCharacters, + FilterReason.duplicate => l10n.messageFilter_reasonDuplicate, + FilterReason.crossSenderDuplicate => + l10n.messageFilter_reasonCrossSenderDuplicate, + FilterReason.learned => l10n.messageFilter_reasonLearned, + FilterReason.manual || null => l10n.messageFilter_reasonManual, + }; +} diff --git a/lib/screens/message_filter_settings_screen.dart b/lib/screens/message_filter_settings_screen.dart new file mode 100644 index 00000000..a62dd0e6 --- /dev/null +++ b/lib/screens/message_filter_settings_screen.dart @@ -0,0 +1,404 @@ +import 'package:flutter/material.dart'; +import 'package:provider/provider.dart'; + +import '../connector/meshcore_connector.dart'; +import '../helpers/snack_bar_builder.dart'; +import '../l10n/l10n.dart'; +import '../models/message_filter.dart'; +import '../services/message_filter/message_filter_service.dart'; +import '../widgets/adaptive_app_bar_title.dart'; +import '../widgets/filter_rule_dialog.dart'; +import '../widgets/mesh_nav_tile.dart'; +import '../widgets/mesh_ui.dart'; +import 'filtered_messages_screen.dart'; + +/// Settings → Message filter: master switch, how filtered messages are shown, +/// the user's own rules and the automatic checks. +class MessageFilterSettingsScreen extends StatelessWidget { + const MessageFilterSettingsScreen({super.key}); + + static const _tilePadding = EdgeInsets.symmetric(horizontal: 16, vertical: 4); + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final service = context.watch(); + final settings = service.settings; + + return Scaffold( + appBar: AppBar( + title: AdaptiveAppBarTitle(l10n.messageFilter_title), + centerTitle: true, + ), + body: SafeArea( + top: false, + child: ListView( + padding: const EdgeInsets.fromLTRB(0, 8, 0, 24), + children: [ + MeshCard( + padding: EdgeInsets.zero, + child: SwitchListTile( + key: const ValueKey('messageFilter_enabledSwitch'), + contentPadding: _tilePadding, + secondary: const Icon(Icons.filter_alt_outlined, size: 24), + title: Text(l10n.messageFilter_enabled), + subtitle: Text(l10n.messageFilter_enabledSubtitle), + value: settings.enabled, + onChanged: (value) => service.updateSettings( + service.settings.copyWith(enabled: value), + ), + ), + ), + + SectionHeader(l10n.messageFilter_displayTitle), + MeshCard( + padding: EdgeInsets.zero, + child: Column( + children: [ + _DisplayModeOptions(service: service), + const Divider(height: 1, indent: 16), + const _FilteredMessagesTile(), + ], + ), + ), + + SectionHeader(l10n.messageFilter_rulesSection), + MeshCard( + padding: EdgeInsets.zero, + child: _RulesList(service: service), + ), + + SectionHeader(l10n.messageFilter_automaticSection), + MeshCard( + padding: EdgeInsets.zero, + child: _AutomaticOptions(service: service), + ), + ], + ), + ), + ); + } +} + +class _DisplayModeOptions extends StatelessWidget { + final MessageFilterService service; + + const _DisplayModeOptions({required this.service}); + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final settings = service.settings; + return RadioGroup( + groupValue: settings.displayMode, + onChanged: (mode) { + if (mode == null || mode == settings.displayMode) return; + service.updateSettings(service.settings.copyWith(displayMode: mode)); + }, + child: Column( + children: [ + RadioListTile( + key: const ValueKey('messageFilter_displayPlaceholder'), + contentPadding: MessageFilterSettingsScreen._tilePadding, + value: FilterDisplayMode.placeholder, + title: Text(l10n.messageFilter_displayPlaceholder), + ), + RadioListTile( + key: const ValueKey('messageFilter_displayHide'), + contentPadding: MessageFilterSettingsScreen._tilePadding, + value: FilterDisplayMode.hide, + title: Text(l10n.messageFilter_displayHide), + subtitle: Text(l10n.messageFilter_displayHideHelp), + ), + ], + ), + ); + } +} + +/// "Filtered messages (N)" row. Rebuilds only when the count changes. +class _FilteredMessagesTile extends StatelessWidget { + const _FilteredMessagesTile(); + + @override + Widget build(BuildContext context) { + final count = context.select( + (c) => c.recentFilteredChannelMessages().length, + ); + return MeshNavTile( + icon: Icons.visibility_off_outlined, + title: context.l10n.messageFilter_filteredMessages(count), + onTap: () => Navigator.push( + context, + MaterialPageRoute(builder: (_) => const FilteredMessagesScreen()), + ), + ); + } +} + +class _RulesList extends StatelessWidget { + final MessageFilterService service; + + const _RulesList({required this.service}); + + Future _addRule(BuildContext context) async { + final rule = await showFilterRuleDialog(context); + if (rule == null) return; + await service.addRule(rule); + if (!context.mounted) return; + showDismissibleSnackBar( + context, + content: Text(context.l10n.messageFilter_ruleSaved), + duration: const Duration(seconds: 2), + ); + } + + Future _editRule(BuildContext context, FilterRule existing) async { + final rule = await showFilterRuleDialog(context, existing: existing); + if (rule == null) return; + await service.updateRule(rule); + if (!context.mounted) return; + showDismissibleSnackBar( + context, + content: Text(context.l10n.messageFilter_ruleSaved), + duration: const Duration(seconds: 2), + ); + } + + Future _deleteRule(BuildContext context, FilterRule rule) async { + final l10n = context.l10n; + // Capture before the await: the row (and its context) goes away with the + // rule, but the undo action must still be able to put it back. + final messenger = ScaffoldMessenger.maybeOf(context); + final index = service.rules.indexWhere((r) => r.id == rule.id); + await service.removeRule(rule.id); + if (messenger == null) return; + messenger.clearSnackBars(); + messenger.showSnackBar( + SnackBar( + content: Text(l10n.messageFilter_ruleDeleted), + duration: const Duration(seconds: 6), + action: SnackBarAction( + label: l10n.common_undo, + onPressed: () => + service.addRule(rule, index: index < 0 ? null : index), + ), + ), + ); + } + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final theme = Theme.of(context); + final rules = service.rules; + + return Column( + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + if (rules.isEmpty) + Padding( + padding: const EdgeInsets.fromLTRB(16, 16, 16, 4), + child: Text( + l10n.messageFilter_rulesEmpty, + style: theme.textTheme.bodyMedium?.copyWith( + color: theme.colorScheme.onSurfaceVariant, + ), + ), + ), + for (var i = 0; i < rules.length; i++) ...[ + if (i > 0) const Divider(height: 1, indent: 16), + _RuleTile( + key: ValueKey('messageFilter_rule_${rules[i].id}'), + rule: rules[i], + onTap: () => _editRule(context, rules[i]), + onEnabledChanged: (value) => + service.updateRule(rules[i].copyWith(enabled: value)), + onDelete: () => _deleteRule(context, rules[i]), + ), + ], + Padding( + padding: const EdgeInsets.fromLTRB(16, 12, 16, 16), + child: Align( + alignment: AlignmentDirectional.centerStart, + child: FilledButton.tonalIcon( + key: const ValueKey('messageFilter_addRuleButton'), + style: FilledButton.styleFrom( + minimumSize: const Size(0, 48), + textStyle: theme.textTheme.titleSmall?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + onPressed: () => _addRule(context), + icon: const Icon(Icons.add, size: 24), + label: Text(l10n.messageFilter_addRule), + ), + ), + ), + ], + ); + } +} + +class _RuleTile extends StatelessWidget { + final FilterRule rule; + final VoidCallback onTap; + final ValueChanged onEnabledChanged; + final VoidCallback onDelete; + + const _RuleTile({ + super.key, + required this.rule, + required this.onTap, + required this.onEnabledChanged, + required this.onDelete, + }); + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final theme = Theme.of(context); + final scheme = theme.colorScheme; + final details = + '${filterRuleFieldLabel(context, rule.field)} · ' + '${filterRuleMatchLabel(context, rule.match)}'; + + return InkWell( + onTap: onTap, + child: Padding( + padding: const EdgeInsetsDirectional.fromSTEB(16, 8, 4, 8), + child: Row( + children: [ + Icon( + rule.field == FilterRuleField.sender + ? Icons.person_outline + : Icons.text_fields, + size: 24, + color: scheme.onSurfaceVariant, + ), + const SizedBox(width: 16), + Expanded( + child: Opacity( + opacity: rule.enabled ? 1 : 0.6, + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + rule.pattern, + maxLines: 2, + overflow: TextOverflow.ellipsis, + style: theme.textTheme.bodyLarge?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + const SizedBox(height: 2), + Text( + details, + style: theme.textTheme.bodyMedium?.copyWith( + color: scheme.onSurfaceVariant, + ), + ), + ], + ), + ), + ), + Switch(value: rule.enabled, onChanged: onEnabledChanged), + IconButton( + tooltip: l10n.common_delete, + icon: const Icon(Icons.delete_outline, size: 24), + color: scheme.onSurfaceVariant, + onPressed: onDelete, + ), + ], + ), + ), + ); + } +} + +class _AutomaticOptions extends StatelessWidget { + final MessageFilterService service; + + const _AutomaticOptions({required this.service}); + + Future _confirmResetLearning(BuildContext context) async { + final l10n = context.l10n; + final confirmed = await showDialog( + context: context, + builder: (dialogContext) => AlertDialog( + title: Text(l10n.messageFilter_resetLearning), + content: Text(l10n.messageFilter_resetLearningConfirm), + actions: [ + TextButton( + onPressed: () => Navigator.pop(dialogContext, false), + child: Text(l10n.common_cancel), + ), + FilledButton( + onPressed: () => Navigator.pop(dialogContext, true), + child: Text(l10n.messageFilter_resetLearning), + ), + ], + ), + ); + if (confirmed == true) await service.resetLearning(); + } + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final settings = service.settings; + final spam = service.spamExampleCount; + final notSpam = service.notSpamExampleCount; + const padding = MessageFilterSettingsScreen._tilePadding; + + return Column( + children: [ + SwitchListTile( + key: const ValueKey('messageFilter_duplicatesSwitch'), + contentPadding: padding, + secondary: const Icon(Icons.copy_all_outlined, size: 24), + title: Text(l10n.messageFilter_duplicates), + subtitle: Text(l10n.messageFilter_duplicatesSubtitle), + value: settings.duplicates, + onChanged: (value) => service.updateSettings( + service.settings.copyWith(duplicates: value), + ), + ), + const Divider(height: 1, indent: 16), + SwitchListTile( + key: const ValueKey('messageFilter_repeatedCharactersSwitch'), + contentPadding: padding, + secondary: const Icon(Icons.more_horiz, size: 24), + title: Text(l10n.messageFilter_repeatedCharacters), + subtitle: Text(l10n.messageFilter_repeatedCharactersSubtitle), + value: settings.repeatedCharacters, + onChanged: (value) => service.updateSettings( + service.settings.copyWith(repeatedCharacters: value), + ), + ), + const Divider(height: 1, indent: 16), + SwitchListTile( + key: const ValueKey('messageFilter_learningSwitch'), + contentPadding: padding, + secondary: const Icon(Icons.school_outlined, size: 24), + title: Text(l10n.messageFilter_learning), + subtitle: Text(l10n.messageFilter_learningSubtitle(spam, notSpam)), + value: settings.learning, + onChanged: (value) => service.updateSettings( + service.settings.copyWith(learning: value), + ), + ), + const Divider(height: 1, indent: 16), + MeshNavTile( + key: const ValueKey('messageFilter_resetLearning'), + icon: Icons.restart_alt, + title: l10n.messageFilter_resetLearning, + showChevron: false, + onTap: spam + notSpam == 0 + ? null + : () => _confirmResetLearning(context), + ), + ], + ); + } +} diff --git a/lib/screens/settings_screen.dart b/lib/screens/settings_screen.dart index 07e8e68e..adcd9919 100644 --- a/lib/screens/settings_screen.dart +++ b/lib/screens/settings_screen.dart @@ -18,6 +18,7 @@ import '../widgets/mesh_ui.dart'; import '../widgets/radio_settings_dialog.dart'; import 'app_settings_screen.dart'; import 'app_debug_log_screen.dart'; +import 'message_filter_settings_screen.dart'; import 'ble_debug_log_screen.dart'; import '../widgets/radio_stats_entry.dart'; import 'telemetry_screen.dart'; @@ -124,14 +125,32 @@ class _SettingsScreenState extends State { SectionHeader(l10n.settings_appSettings), MeshCard( padding: EdgeInsets.zero, - child: MeshNavTile( - icon: Icons.settings_outlined, - title: l10n.settings_appSettings, - subtitle: l10n.settings_appSettingsSubtitle, - onTap: () => Navigator.push( - context, - MaterialPageRoute(builder: (_) => const AppSettingsScreen()), - ), + child: Column( + children: [ + MeshNavTile( + icon: Icons.settings_outlined, + title: l10n.settings_appSettings, + subtitle: l10n.settings_appSettingsSubtitle, + onTap: () => Navigator.push( + context, + MaterialPageRoute( + builder: (_) => const AppSettingsScreen(), + ), + ), + ), + const Divider(height: 1, indent: 16), + MeshNavTile( + icon: Icons.filter_alt_outlined, + title: l10n.messageFilter_title, + subtitle: l10n.messageFilter_settingsSubtitle, + onTap: () => Navigator.push( + context, + MaterialPageRoute( + builder: (_) => const MessageFilterSettingsScreen(), + ), + ), + ), + ], ), ), diff --git a/lib/services/message_filter/duplicate_tracker.dart b/lib/services/message_filter/duplicate_tracker.dart new file mode 100644 index 00000000..9a3d2cf2 --- /dev/null +++ b/lib/services/message_filter/duplicate_tracker.dart @@ -0,0 +1,145 @@ +import 'dart:collection'; + +import '../../models/message_filter.dart'; +import 'message_filter_text.dart'; + +class _SeenMessage { + final String sender; + final String key; + + /// When the sender sent it (their clock). Windows compare these. + final DateTime sentAt; + + /// When this device saw it (local clock). Only used to forget entries. + final DateTime receivedAt; + const _SeenMessage(this.sender, this.key, this.sentAt, this.receivedAt); +} + +/// In-memory, per-channel tracker of recently seen channel texts used to catch +/// repeated messages (same sender) and floods (same text from several senders). +/// +/// Every checked text is recorded, including ones that end up filtered, so a +/// flood keeps being caught. +/// +/// Windows are measured between the messages' own send times, as an absolute +/// difference, so history downloaded in a burst after reconnecting (sent +/// hours apart, delivered seconds apart, possibly out of order) is not +/// mistaken for a flood. Entries are forgotten by local receive time instead, +/// so a sender whose clock is far off cannot push everyone else's entries +/// out early or keep its own around forever. +/// +/// The cross-sender rule only applies to sentence-length texts (at least +/// [crossSenderMinWords] words): short greetings like "Happy New Year!" or +/// "Good morning everyone" are naturally sent by many people at once, while +/// copy-paste campaigns from rotating identities are whole sentences. +class DuplicateTracker { + DuplicateTracker({ + this.sameSenderWindow = const Duration(minutes: 10), + this.crossSenderWindow = const Duration(minutes: 30), + this.crossSenderMinSenders = 3, + this.crossSenderMinLength = 10, + this.crossSenderMinWords = 6, + this.maxEntriesPerChannel = 1000, + }); + + final Duration sameSenderWindow; + final Duration crossSenderWindow; + final int crossSenderMinSenders; + final int crossSenderMinLength; + + /// Minimum word count for the cross-sender rule (see class docs). + final int crossSenderMinWords; + final int maxEntriesPerChannel; + + final Map> _seen = {}; + final Map> _allowed = {}; + + Duration get _retention => sameSenderWindow > crossSenderWindow + ? sameSenderWindow + : crossSenderWindow; + + static String _senderKey(String sender) => + MessageFilterText.normalize(sender); + + void _prune(ListQueue<_SeenMessage> entries, DateTime receivedAt) { + // Entries are appended in receive order, so the oldest are at the front. + final cutoff = receivedAt.subtract(_retention); + while (entries.isNotEmpty && entries.first.receivedAt.isBefore(cutoff)) { + entries.removeFirst(); + } + while (entries.length > maxEntriesPerChannel) { + entries.removeFirst(); + } + } + + /// Records the text and returns [FilterReason.duplicate], + /// [FilterReason.crossSenderDuplicate] or null. + /// + /// [at] is when the message was sent (the sender's timestamp); windows are + /// compared on it. [receivedAt] (default [at]) is the local time it arrived, + /// used only to forget old entries. + FilterReason? check({ + required String channelId, + required String sender, + required String text, + required DateTime at, + DateTime? receivedAt, + }) { + final arrived = receivedAt ?? at; + final key = MessageFilterText.normalizeForDuplicates(text); + if (key.isEmpty) return null; + final senderKey = _senderKey(sender); + final entries = _seen.putIfAbsent(channelId, ListQueue<_SeenMessage>.new); + _prune(entries, arrived); + + FilterReason? result; + if (!isAllowed(channelId, text)) { + final senders = {senderKey}; + var sameSender = false; + for (final entry in entries) { + if (entry.key != key) continue; + // Absolute gap between send times: delivery order does not matter. + final gap = entry.sentAt.difference(at).abs(); + if (entry.sender == senderKey) { + if (gap <= sameSenderWindow) sameSender = true; + } else if (gap <= crossSenderWindow) { + senders.add(entry.sender); + } + } + if (sameSender) { + result = FilterReason.duplicate; + } else if (key.length >= crossSenderMinLength && + _wordCount(key) >= crossSenderMinWords && + senders.length >= crossSenderMinSenders) { + result = FilterReason.crossSenderDuplicate; + } + } + + entries.addLast(_SeenMessage(senderKey, key, at, arrived)); + if (entries.length > maxEntriesPerChannel) entries.removeFirst(); + return result; + } + + /// [key] is already whitespace-collapsed by `normalizeForDuplicates`. + static int _wordCount(String key) => key.isEmpty ? 0 : key.split(' ').length; + + /// Exempts this text in this channel from duplicate hits for the session + /// (used after "Not spam"). + void allow(String channelId, String text) { + final key = MessageFilterText.normalizeForDuplicates(text); + if (key.isEmpty) return; + _allowed.putIfAbsent(channelId, () => {}).add(key); + } + + bool isAllowed(String channelId, String text) { + final allowed = _allowed[channelId]; + if (allowed == null || allowed.isEmpty) return false; + return allowed.contains(MessageFilterText.normalizeForDuplicates(text)); + } + + /// Forgets everything (seen texts and the allow-set). + void clear() { + _seen.clear(); + _allowed.clear(); + } +} diff --git a/lib/services/message_filter/message_filter_service.dart b/lib/services/message_filter/message_filter_service.dart new file mode 100644 index 00000000..18545ba0 --- /dev/null +++ b/lib/services/message_filter/message_filter_service.dart @@ -0,0 +1,394 @@ +import 'dart:async'; + +import 'package:flutter/foundation.dart'; + +import '../../models/message_filter.dart'; +import '../../storage/message_filter_store.dart'; +import 'duplicate_tracker.dart'; +import 'message_filter_text.dart'; +import 'ngram_spam_classifier.dart'; + +/// Decides whether incoming channel messages should be filtered, and owns the +/// filter's settings, user rules and the learned classifier. +/// +/// Filtered messages are never deleted; callers only tag them with the +/// returned [FilterVerdict]. +class MessageFilterService extends ChangeNotifier { + MessageFilterService({ + MessageFilterStore? store, + DateTime Function()? clock, + DuplicateTracker? duplicateTracker, + NgramSpamClassifier? classifier, + }) : _store = store ?? MessageFilterStore(), + _clock = clock ?? DateTime.now, + _tracker = duplicateTracker ?? DuplicateTracker(), + _classifier = classifier ?? NgramSpamClassifier(); + + /// Minimum classifier probability for a [FilterReason.learned] verdict. + static const double learnedThreshold = 0.80; + + /// Spam taps needed before the learned classifier is consulted. + static const int minSpamExamplesForLearning = 2; + + static const int maxSpamExamples = 200; + static const int maxNotSpamExamples = 200; + static const int maxRecentClean = 300; + + /// Longest text kept as a training example (longer text is truncated). + static const int maxExampleTextLength = 500; + + /// Recent-clean entries buffered before they are written to storage. + static const int _recentCleanSaveEvery = 10; + + final MessageFilterStore _store; + final DateTime Function() _clock; + final DuplicateTracker _tracker; + final NgramSpamClassifier _classifier; + + MessageFilterSettings _settings = MessageFilterSettings.defaults; + List _rules = []; + List _spamExamples = []; + List _hamExamples = []; + List _recentClean = []; + int _unsavedCleanCount = 0; + bool _disposed = false; + + /// A retrain is queued (see [_scheduleRetrainIfInactive]). + bool _retrainPending = false; + + static int _idCounter = 0; + + /// Unique-enough rule id: microsecond timestamp plus a process counter. + static String newRuleId() { + final micros = DateTime.now().microsecondsSinceEpoch.toRadixString(36); + final counter = (_idCounter++).toRadixString(36); + return 'r$micros$counter'; + } + + MessageFilterSettings get settings => _settings; + List get rules => List.unmodifiable(_rules); + int get spamExampleCount => _spamExamples.length; + int get notSpamExampleCount => _hamExamples.length; + + /// Implicit "not spam" examples currently remembered (for tests). + @visibleForTesting + int get recentCleanCount => _recentClean.length; + + /// Loads persisted state and trains the classifier. + Future load() async { + try { + _settings = _store.loadSettings(); + _rules = _store.loadRules(); + _spamExamples = _store.loadSpamExamples(); + _hamExamples = _store.loadHamExamples(); + _recentClean = _store.loadRecentClean(); + } catch (e) { + debugPrint('MessageFilterService: load failed: $e'); + } + _trimToCap(_spamExamples, maxSpamExamples); + _trimToCap(_hamExamples, maxNotSpamExamples); + _trimToCap(_recentClean, maxRecentClean); + _unsavedCleanCount = 0; + _retrain(); + _notify(); + } + + /// Whether filtering applies to [channelId] (master switch on and the + /// channel not excluded). + bool isChannelFiltered(String channelId) => + _settings.enabled && !_settings.excludedChannelIds.contains(channelId); + + /// Evaluates an incoming channel message. Returns a verdict when the message + /// should be filtered, otherwise null. Records the text for duplicate + /// detection whenever the message is eligible for filtering at all. + /// + /// [sentAt] is the message's own timestamp. Duplicate windows are measured + /// between send times, so history synced in a burst after reconnecting is + /// not mistaken for a flood; without it the local clock is used. + FilterVerdict? evaluate({ + required String channelId, + required String sender, + required String text, + DateTime? sentAt, + bool isOutgoing = false, + bool isReaction = false, + }) { + if (!isChannelFiltered(channelId)) return null; + if (isOutgoing || isReaction) return null; + if (text.trim().isEmpty) return null; + if (MessageFilterText.isStructuredPayload(text)) return null; + + // Always record (even when a rule matches) so floods keep being caught. + final duplicateReason = _tracker.check( + channelId: channelId, + sender: sender, + text: text, + at: sentAt ?? _clock(), + receivedAt: _clock(), + ); + + for (final rule in _rules) { + if (!rule.enabled || rule.field == FilterRuleField.text) continue; + if (MessageFilterText.matchesSender(rule, sender)) { + return FilterVerdict( + reason: FilterReason.senderRule, + detail: rule.pattern, + ); + } + } + for (final rule in _rules) { + if (!rule.enabled || rule.field == FilterRuleField.sender) continue; + if (MessageFilterText.matchesText(rule, text)) { + return FilterVerdict( + reason: FilterReason.textRule, + detail: rule.pattern, + ); + } + } + + if (_settings.repeatedCharacters && + MessageFilterText.hasRepeatedCharacters(text)) { + return const FilterVerdict(reason: FilterReason.repeatedCharacters); + } + + if (_settings.duplicates && duplicateReason != null) { + return FilterVerdict(reason: duplicateReason); + } + + if (_settings.learning && + _spamExamples.length >= minSpamExamplesForLearning && + _classifier.isTrained && + !_tracker.isAllowed(channelId, text)) { + final probability = _classifier.probability(sender, text); + if (probability >= learnedThreshold) { + return const FilterVerdict(reason: FilterReason.learned); + } + } + return null; + } + + /// Remembers an unfiltered incoming message as an implicit "not spam" + /// training example (rolling buffer of [maxRecentClean]). + void recordClean({required String sender, required String text}) { + if (!_settings.enabled || !_settings.learning) return; + if (text.trim().isEmpty || MessageFilterText.isStructuredPayload(text)) { + return; + } + final example = _example(sender, text); + if (_recentClean.isNotEmpty) { + final last = _recentClean.last; + if (last.sender == example.sender && last.text == example.text) return; + } + _recentClean.add(example); + _trimToCap(_recentClean, maxRecentClean); + _unsavedCleanCount++; + if (_unsavedCleanCount >= _recentCleanSaveEvery) { + _saveRecentClean(); + } + _scheduleRetrainIfInactive(); + } + + /// The classifier needs both spam and clean examples to train. When the + /// user has marked enough spam but training had no clean examples yet (for + /// example the first messages received were the ones marked), it stays + /// untrained; the first clean example to arrive afterwards activates it. + /// Runs once, as a microtask, so message intake is not blocked and a burst + /// of clean messages trains a single time. + void _scheduleRetrainIfInactive() { + if (_retrainPending || _classifier.isTrained) return; + if (_spamExamples.length < minSpamExamplesForLearning) return; + _retrainPending = true; + scheduleMicrotask(() { + _retrainPending = false; + if (_disposed || _classifier.isTrained) return; + _retrain(); + }); + } + + /// User tapped "Spam": store the example and retrain. + Future markSpam({required String sender, required String text}) async { + final key = MessageFilterText.normalize(text); + if (key.isEmpty) return; + _recentClean.removeWhere((e) => MessageFilterText.normalize(e.text) == key); + _hamExamples.removeWhere((e) => MessageFilterText.normalize(e.text) == key); + _addExample(_spamExamples, _example(sender, text), maxSpamExamples); + _retrain(); + _notify(); + await _guardSave(() async { + await _store.saveSpamExamples(_spamExamples); + await _store.saveHamExamples(_hamExamples); + await _flushRecentClean(); + }); + } + + /// User tapped "Not spam": store the example, exempt this text in this + /// channel from duplicate and learned hits for the session, and retrain. + Future markNotSpam({ + required String channelId, + required String sender, + required String text, + }) async { + _tracker.allow(channelId, text); + final key = MessageFilterText.normalize(text); + if (key.isEmpty) { + _notify(); + return; + } + _spamExamples.removeWhere( + (e) => MessageFilterText.normalize(e.text) == key, + ); + _addExample(_hamExamples, _example(sender, text), maxNotSpamExamples); + _retrain(); + _notify(); + await _guardSave(() async { + await _store.saveSpamExamples(_spamExamples); + await _store.saveHamExamples(_hamExamples); + }); + } + + Future updateSettings(MessageFilterSettings settings) async { + final learningTurnedOn = settings.learning && !_settings.learning; + _settings = settings; + if (learningTurnedOn) _retrain(); + _notify(); + await _guardSave(() => _store.saveSettings(_settings)); + } + + Future setChannelExcluded(String channelId, bool excluded) async { + final current = _settings.excludedChannelIds; + if (current.contains(channelId) == excluded) return; + final next = Set.of(current); + if (excluded) { + next.add(channelId); + } else { + next.remove(channelId); + } + await updateSettings(_settings.copyWith(excludedChannelIds: next)); + } + + /// Adds [rule] (replacing any rule with the same id) at the end, or at + /// [index] (clamped) when given, e.g. to undo a delete in place. + Future addRule(FilterRule rule, {int? index}) async { + final others = _rules.where((r) => r.id != rule.id).toList(); + if (index == null) { + others.add(rule); + } else { + others.insert(index.clamp(0, others.length), rule); + } + _rules = others; + _notify(); + await _guardSave(() => _store.saveRules(_rules)); + } + + Future updateRule(FilterRule rule) async { + final index = _rules.indexWhere((r) => r.id == rule.id); + if (index < 0) { + await addRule(rule); + return; + } + _rules = List.of(_rules)..[index] = rule; + _notify(); + await _guardSave(() => _store.saveRules(_rules)); + } + + Future removeRule(String id) async { + final before = _rules.length; + _rules = _rules.where((r) => r.id != id).toList(); + if (_rules.length == before) return; + _notify(); + await _guardSave(() => _store.saveRules(_rules)); + } + + /// Forgets all Spam / Not spam taps and implicit examples. Rules are kept. + Future resetLearning() async { + _spamExamples = []; + _hamExamples = []; + _recentClean = []; + _unsavedCleanCount = 0; + _classifier.reset(); + _notify(); + await _guardSave(() async { + await _store.saveSpamExamples(_spamExamples); + await _store.saveHamExamples(_hamExamples); + await _store.saveRecentClean(_recentClean); + }); + } + + @override + void dispose() { + _disposed = true; + if (_unsavedCleanCount > 0) _saveRecentClean(); + super.dispose(); + } + + // --------------------------------------------------------------------------- + + FilterExample _example(String sender, String text) { + final trimmed = text.trim(); + return FilterExample( + sender: sender, + text: trimmed.length > maxExampleTextLength + ? trimmed.substring(0, maxExampleTextLength) + : trimmed, + addedAtMs: _clock().millisecondsSinceEpoch, + ); + } + + /// Adds [example] as the newest entry, replacing an identical one. + static void _addExample( + List list, + FilterExample example, + int cap, + ) { + final key = MessageFilterText.normalize(example.text); + final sender = MessageFilterText.normalize(example.sender); + list.removeWhere( + (e) => + MessageFilterText.normalize(e.text) == key && + MessageFilterText.normalize(e.sender) == sender, + ); + list.add(example); + _trimToCap(list, cap); + } + + static void _trimToCap(List list, int cap) { + if (list.length > cap) list.removeRange(0, list.length - cap); + } + + void _retrain() { + if (_spamExamples.isEmpty) { + _classifier.reset(); + return; + } + final stopwatch = Stopwatch()..start(); + _classifier.train(_spamExamples, [..._hamExamples, ..._recentClean]); + stopwatch.stop(); + if (stopwatch.elapsedMilliseconds > 200) { + debugPrint( + 'MessageFilterService: classifier training took ' + '${stopwatch.elapsedMilliseconds} ms', + ); + } + } + + Future _flushRecentClean() async { + _unsavedCleanCount = 0; + await _store.saveRecentClean(_recentClean); + } + + void _saveRecentClean() { + _guardSave(_flushRecentClean); + } + + Future _guardSave(Future Function() save) async { + try { + await save(); + } catch (e) { + debugPrint('MessageFilterService: save failed: $e'); + } + } + + void _notify() { + if (!_disposed) notifyListeners(); + } +} diff --git a/lib/services/message_filter/message_filter_text.dart b/lib/services/message_filter/message_filter_text.dart new file mode 100644 index 00000000..e697d5f7 --- /dev/null +++ b/lib/services/message_filter/message_filter_text.dart @@ -0,0 +1,221 @@ +import '../../models/app_settings.dart' show defaultCyr2LatCharMap; +import '../../models/message_filter.dart'; + +/// Text helpers shared by the message filter: normalization (so look-alike +/// characters, accents and invisible characters cannot dodge a rule), rule +/// matching and the structured-payload check. +class MessageFilterText { + MessageFilterText._(); + + static final RegExp _whitespace = RegExp(r'\s+', unicode: true); + static final RegExp _mention = RegExp(r'@\[[^\]]*\]'); + static final RegExp _nonWordChars = RegExp( + r'[^\p{L}\p{N}\s]+', + unicode: true, + ); + static final RegExp _repeatedChars = RegExp(r'(\S)\1{7,}', unicode: true); + + static final Map _foldMap = _buildFoldMap(); + + static Map _buildFoldMap() { + final map = {}; + void addAll(String chars, String replacement) { + for (final rune in chars.runes) { + map[rune] = replacement; + } + } + + // Accented Latin (lower case only: input is lower-cased first). + addAll('àáâãäåāăąǎȁȃạảấầẩẫậắằẳẵặ', 'a'); + addAll('çćĉċč', 'c'); + addAll('ďđ', 'd'); + addAll('èéêëēĕėęěȅȇẹẻẽếềểễệ', 'e'); + addAll('ĝğġģ', 'g'); + addAll('ĥħ', 'h'); + addAll('ìíîïĩīĭįıǐȉȋỉị', 'i'); + addAll('ĵ', 'j'); + addAll('ķ', 'k'); + addAll('ĺļľŀł', 'l'); + addAll('ñńņňʼn', 'n'); + addAll('òóôõöøōŏőǒȍȏọỏốồổỗộớờởỡợơ', 'o'); + addAll('ŕŗř', 'r'); + addAll('śŝşšș', 's'); + addAll('ţťŧț', 't'); + addAll('ùúûüũūŭůűųǔȕȗụủứừửữựư', 'u'); + addAll('ŵ', 'w'); + addAll('ýÿŷỳỵỷỹ', 'y'); + addAll('źżž', 'z'); + map['ß'.runes.first] = 'ss'; + map['æ'.runes.first] = 'ae'; + map['œ'.runes.first] = 'oe'; + map['þ'.runes.first] = 'th'; + + // Cyrillic look-alikes (reuse the app's Cyr2Lat table, lower-cased). + defaultCyr2LatCharMap.forEach((from, to) { + map[from.toLowerCase().runes.first] = to.toLowerCase(); + }); + + // Greek look-alikes. + const greek = { + 'ο': 'o', + 'α': 'a', + 'ε': 'e', + 'ι': 'i', + 'κ': 'k', + 'ν': 'v', + 'ρ': 'p', + 'τ': 't', + 'υ': 'u', + 'χ': 'x', + }; + greek.forEach((from, to) => map[from.runes.first] = to); + return map; + } + + static bool _isInvisible(int rune) => + (rune >= 0x200B && rune <= 0x200D) || + rune == 0x2060 || + rune == 0xFEFF || + rune == 0x00AD; + + static bool _isCombiningMark(int rune) => + (rune >= 0x0300 && rune <= 0x036F) || + (rune >= 0x1AB0 && rune <= 0x1AFF) || + (rune >= 0x1DC0 && rune <= 0x1DFF) || + (rune >= 0x20D0 && rune <= 0x20FF) || + (rune >= 0xFE20 && rune <= 0xFE2F); + + /// Maps fullwidth and "mathematical" styled letters/digits (bold, italic, + /// script, …) to plain ASCII, returning null for everything else. + static int? _foldStyledAscii(int rune) { + // Fullwidth forms. + if (rune >= 0xFF41 && rune <= 0xFF5A) return 0x61 + rune - 0xFF41; + if (rune >= 0xFF21 && rune <= 0xFF3A) return 0x61 + rune - 0xFF21; + if (rune >= 0xFF10 && rune <= 0xFF19) return 0x30 + rune - 0xFF10; + // Mathematical alphanumeric symbols: repeating A-Z a-z blocks. + if (rune >= 0x1D400 && rune <= 0x1D6A3) { + final offset = (rune - 0x1D400) % 52; + return 0x61 + (offset < 26 ? offset : offset - 26); + } + if (rune >= 0x1D7CE && rune <= 0x1D7FF) { + return 0x30 + (rune - 0x1D7CE) % 10; + } + return null; + } + + /// Lower-cases, folds accents and look-alike characters, removes invisible + /// characters and leaves the whitespace untouched. + static String _fold(String text) { + final lower = text.toLowerCase(); + final buffer = StringBuffer(); + for (final rune in lower.runes) { + if (_isInvisible(rune) || _isCombiningMark(rune)) continue; + final styled = _foldStyledAscii(rune); + if (styled != null) { + buffer.writeCharCode(styled); + continue; + } + final mapped = _foldMap[rune]; + if (mapped != null) { + buffer.write(mapped); + } else { + buffer.writeCharCode(rune); + } + } + return buffer.toString(); + } + + /// Canonical form used for rule matching and classifier features. + static String normalize(String text) { + if (text.isEmpty) return ''; + return _fold(text).replaceAll(_whitespace, ' ').trim(); + } + + /// Looser form used to detect repeated messages: also drops `@[name]` + /// mentions, punctuation and emoji so trivial variations still match. + static String normalizeForDuplicates(String text) { + final normalized = normalize(text); + if (normalized.isEmpty) return ''; + return normalized + .replaceAll(_mention, ' ') + .replaceAll(_nonWordChars, ' ') + .replaceAll(_whitespace, ' ') + .trim(); + } + + /// True when the same visible character appears 8 or more times in a row. + /// + /// Whitespace runs are ignored (they are layout, not content). + static bool hasRepeatedCharacters(String text) { + if (text.length < 8) return false; + return _repeatedChars.hasMatch(_fold(text)); + } + + /// GIF / structured payloads (same check as the channel send path). + static bool isStructuredPayload(String text) { + final trimmed = text.trim(); + return trimmed.startsWith('g:') || trimmed.startsWith('m:'); + } + + static final Map _wholeWordCache = {}; + + static RegExp _wholeWordRegExp(String normalizedPattern) { + final cached = _wholeWordCache[normalizedPattern]; + if (cached != null) return cached; + if (_wholeWordCache.length > 256) _wholeWordCache.clear(); + final regExp = RegExp( + '(? + _matchesNormalized( + normalize(rule.pattern), + rule.match, + normalize(sender), + ); + + /// Whether [rule]'s pattern matches [text] (ignores the rule's field). + static bool matchesText(FilterRule rule, String text) => + _matchesNormalized(normalize(rule.pattern), rule.match, normalize(text)); + + /// Whether [rule] matches the message, honouring the rule's field. + /// + /// The rule's `enabled` flag is not checked here; callers decide whether + /// disabled rules apply. + static bool matchesRule( + FilterRule rule, { + required String sender, + required String text, + }) { + switch (rule.field) { + case FilterRuleField.sender: + return matchesSender(rule, sender); + case FilterRuleField.text: + return matchesText(rule, text); + case FilterRuleField.both: + return matchesSender(rule, sender) || matchesText(rule, text); + } + } +} diff --git a/lib/services/message_filter/ngram_spam_classifier.dart b/lib/services/message_filter/ngram_spam_classifier.dart new file mode 100644 index 00000000..5e3a8dbf --- /dev/null +++ b/lib/services/message_filter/ngram_spam_classifier.dart @@ -0,0 +1,230 @@ +import 'dart:math' as math; +import 'dart:typed_data'; + +import '../../models/message_filter.dart'; +import 'message_filter_text.dart'; + +/// A sparse, L2-normalised feature vector (hashed bucket ids and values). +class _SparseVector { + final Int32List indices; + final Float64List values; + const _SparseVector(this.indices, this.values); +} + +/// Small on-device spam classifier trained from the user's "Spam" and +/// "Not spam" taps. +/// +/// Features are hashed character n-grams (3..5, within word boundaries), word +/// unigrams/bigrams and the sender name; the model is a class-balanced, +/// L2-regularised logistic regression trained with seeded SGD. Training and +/// scoring are pure Dart and fully deterministic for the same inputs. +class NgramSpamClassifier { + NgramSpamClassifier({ + this.epochs = 200, + this.learningRate = 0.5, + this.lambda = 1e-4, + this.seed = 42, + }); + + static const int bucketBits = 18; + static const int bucketCount = 1 << bucketBits; + static const int _bucketMask = bucketCount - 1; + static const int minCharGram = 3; + static const int maxCharGram = 5; + + final int epochs; + final double learningRate; + final double lambda; + final int seed; + + Map _weights = const {}; + double _bias = 0; + bool _trained = false; + + bool get isTrained => _trained; + + /// Number of non-zero weights in the trained model. + int get featureCount => _weights.length; + + void reset() { + _weights = const {}; + _bias = 0; + _trained = false; + } + + static final RegExp _wordToken = RegExp(r'[\p{L}\p{N}]+', unicode: true); + + /// Stable 32-bit FNV-1a over the UTF-16 code units of [value]. + /// + /// The prime multiply is split (0x01000193 = 2^24 + 0x193) so intermediate + /// values stay below 2^53 and the result is identical on the web. + static int fnv1a32(String value) { + var hash = 0x811C9DC5; + for (var i = 0; i < value.length; i++) { + hash = (hash ^ value.codeUnitAt(i)) & 0xFFFFFFFF; + hash = (hash * 0x193 + ((hash & 0xFF) << 24)) & 0xFFFFFFFF; + } + return hash; + } + + /// Raw (unhashed) feature strings for a message, exposed for tests. + static List featureStrings(String sender, String text) { + final features = []; + final normalized = MessageFilterText.normalize(text); + if (normalized.isNotEmpty) { + for (final word in normalized.split(' ')) { + if (word.isEmpty) continue; + final padded = ' $word '; + if (padded.length <= minCharGram) { + features.add('c:$padded'); + continue; + } + for (var n = minCharGram; n <= maxCharGram; n++) { + if (padded.length < n) { + features.add('c:$padded'); + break; + } + for (var i = 0; i + n <= padded.length; i++) { + features.add('c:${padded.substring(i, i + n)}'); + } + } + } + final words = _wordToken + .allMatches(normalized) + .map((m) => m.group(0)!) + .toList(growable: false); + for (var i = 0; i < words.length; i++) { + features.add('w:${words[i]}'); + if (i + 1 < words.length) { + features.add('b:${words[i]} ${words[i + 1]}'); + } + } + } + final normalizedSender = MessageFilterText.normalize(sender); + if (normalizedSender.isNotEmpty) { + features.add('s:$normalizedSender'); + } + return features; + } + + static _SparseVector _vectorize(String sender, String text) { + final counts = {}; + for (final feature in featureStrings(sender, text)) { + final bucket = fnv1a32(feature) & _bucketMask; + counts[bucket] = (counts[bucket] ?? 0) + 1; + } + final keys = counts.keys.toList()..sort(); + final indices = Int32List(keys.length); + final values = Float64List(keys.length); + var sumSquares = 0.0; + for (var i = 0; i < keys.length; i++) { + final value = 1 + math.log(counts[keys[i]]!); + indices[i] = keys[i]; + values[i] = value; + sumSquares += value * value; + } + if (sumSquares > 0) { + final norm = math.sqrt(sumSquares); + for (var i = 0; i < values.length; i++) { + values[i] /= norm; + } + } + return _SparseVector(indices, values); + } + + static double _sigmoid(double z) { + if (z >= 0) { + return 1 / (1 + math.exp(-z)); + } + final e = math.exp(z); + return e / (1 + e); + } + + /// Trains from scratch. Needs at least one example of each class; otherwise + /// the classifier is left untrained (and [probability] returns 0). + void train(List spam, List ham) { + reset(); + if (spam.isEmpty || ham.isEmpty) return; + + // Vectorize and remap hashed buckets to a compact local index space. + final localIndex = {}; + final docs = <_SparseVector>[]; + final labels = []; + void addDoc(FilterExample example, double label) { + final vector = _vectorize(example.sender, example.text); + if (vector.indices.isEmpty) return; + final local = Int32List(vector.indices.length); + for (var i = 0; i < vector.indices.length; i++) { + local[i] = localIndex.putIfAbsent( + vector.indices[i], + () => localIndex.length, + ); + } + docs.add(_SparseVector(local, vector.values)); + labels.add(label); + } + + for (final example in spam) { + addDoc(example, 1); + } + for (final example in ham) { + addDoc(example, 0); + } + + final n = docs.length; + final nPos = labels.where((y) => y == 1).length; + final nNeg = n - nPos; + if (nPos == 0 || nNeg == 0) return; + final wPos = n / (2 * nPos); + final wNeg = n / (2 * nNeg); + + final weights = Float64List(localIndex.length); + var bias = 0.0; + final order = List.generate(n, (i) => i); + final random = math.Random(seed); + // Per-step decay; lambda is the per-sample L2 strength. + final decay = 1 - learningRate * lambda; + + for (var epoch = 0; epoch < epochs; epoch++) { + order.shuffle(random); + final rate = learningRate / (1 + epoch * 0.02); + for (final docIndex in order) { + final doc = docs[docIndex]; + final y = labels[docIndex]; + var z = bias; + for (var i = 0; i < doc.indices.length; i++) { + z += weights[doc.indices[i]] * doc.values[i]; + } + final sampleWeight = y == 1 ? wPos : wNeg; + final gradient = (_sigmoid(z) - y) * sampleWeight; + for (var i = 0; i < doc.indices.length; i++) { + final j = doc.indices[i]; + weights[j] = weights[j] * decay - rate * gradient * doc.values[i]; + } + bias -= rate * gradient; + } + } + + final compact = {}; + localIndex.forEach((bucket, local) { + final weight = weights[local]; + if (weight != 0) compact[bucket] = weight; + }); + _weights = compact; + _bias = bias; + _trained = true; + } + + /// Probability (0..1) that the message is spam; 0 when untrained. + double probability(String sender, String text) { + if (!_trained) return 0.0; + final vector = _vectorize(sender, text); + if (vector.indices.isEmpty) return 0.0; + var z = _bias; + for (var i = 0; i < vector.indices.length; i++) { + final weight = _weights[vector.indices[i]]; + if (weight != null) z += weight * vector.values[i]; + } + return _sigmoid(z); + } +} diff --git a/lib/storage/channel_message_store.dart b/lib/storage/channel_message_store.dart index a5adc395..81294344 100644 --- a/lib/storage/channel_message_store.dart +++ b/lib/storage/channel_message_store.dart @@ -199,6 +199,8 @@ class ChannelMessageStore { 'replyToSenderName': msg.replyToSenderName, 'replyToText': msg.replyToText, 'reactions': msg.reactions, + if (msg.filterReason != null) 'filterReason': msg.filterReason, + if (msg.filterDetail != null) 'filterDetail': msg.filterDetail, // `text` is stored decoded; legacy records without this flag may still // hold a Smaz payload. 'plainText': true, @@ -289,6 +291,8 @@ class ChannelMessageStore { ), ) ?? {}, + filterReason: json['filterReason'] as String?, + filterDetail: json['filterDetail'] as String?, ); } diff --git a/lib/storage/message_filter_store.dart b/lib/storage/message_filter_store.dart new file mode 100644 index 00000000..68801912 --- /dev/null +++ b/lib/storage/message_filter_store.dart @@ -0,0 +1,104 @@ +import 'dart:convert'; + +import 'package:flutter/foundation.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +import '../models/message_filter.dart'; +import 'prefs_manager.dart'; + +/// Global (not per-radio) persistence for the message filter: settings, user +/// rules and the classifier's training examples. Values are JSON strings in +/// SharedPreferences. Loads are synchronous; saves are async. +/// +/// Malformed stored data is tolerated: bad records are skipped and missing or +/// unreadable values fall back to defaults. +class MessageFilterStore { + static const String settingsKey = 'message_filter_settings'; + static const String rulesKey = 'message_filter_rules'; + static const String spamExamplesKey = 'message_filter_spam_examples'; + static const String hamExamplesKey = 'message_filter_ham_examples'; + static const String recentCleanKey = 'message_filter_recent_clean'; + + SharedPreferences? get _prefs { + try { + return PrefsManager.instance; + } on StateError { + return null; + } + } + + Object? _decode(String key) { + final raw = _prefs?.getString(key); + if (raw == null || raw.isEmpty) return null; + try { + return jsonDecode(raw); + } catch (e) { + debugPrint('MessageFilterStore: failed to decode $key: $e'); + return null; + } + } + + List _decodeList( + String key, + T Function(Map json) fromJson, + ) { + final decoded = _decode(key); + if (decoded is! List) return []; + final result = []; + for (final item in decoded) { + if (item is! Map) continue; + try { + result.add(fromJson(Map.from(item))); + } catch (e) { + debugPrint('MessageFilterStore: skipping bad record in $key: $e'); + } + } + return result; + } + + Future _encode(String key, Object value) async { + final prefs = _prefs; + if (prefs == null) return; + await prefs.setString(key, jsonEncode(value)); + } + + MessageFilterSettings loadSettings() { + final decoded = _decode(settingsKey); + if (decoded is! Map) return MessageFilterSettings.defaults; + try { + return MessageFilterSettings.fromJson(Map.from(decoded)); + } catch (e) { + debugPrint('MessageFilterStore: bad settings: $e'); + return MessageFilterSettings.defaults; + } + } + + Future saveSettings(MessageFilterSettings settings) => + _encode(settingsKey, settings.toJson()); + + List loadRules() => _decodeList( + rulesKey, + FilterRule.fromJson, + ).where((rule) => rule.id.isNotEmpty && rule.pattern.isNotEmpty).toList(); + + Future saveRules(List rules) => + _encode(rulesKey, rules.map((r) => r.toJson()).toList()); + + List loadSpamExamples() => + _decodeList(spamExamplesKey, FilterExample.fromJson); + + Future saveSpamExamples(List examples) => + _encode(spamExamplesKey, examples.map((e) => e.toJson()).toList()); + + List loadHamExamples() => + _decodeList(hamExamplesKey, FilterExample.fromJson); + + Future saveHamExamples(List examples) => + _encode(hamExamplesKey, examples.map((e) => e.toJson()).toList()); + + List loadRecentClean() => + _decodeList(recentCleanKey, FilterExample.fromJson); + + Future saveRecentClean(List examples) => + _encode(recentCleanKey, examples.map((e) => e.toJson()).toList()); +} diff --git a/lib/widgets/filter_rule_dialog.dart b/lib/widgets/filter_rule_dialog.dart new file mode 100644 index 00000000..a415aa41 --- /dev/null +++ b/lib/widgets/filter_rule_dialog.dart @@ -0,0 +1,198 @@ +import 'package:flutter/material.dart'; + +import '../l10n/l10n.dart'; +import '../models/message_filter.dart'; +import '../services/message_filter/message_filter_service.dart'; + +/// Opens the add / edit dialog for a message filter rule. +/// +/// Returns the rule to save, or null when the user cancels. The caller +/// persists it (`MessageFilterService.addRule` / `updateRule`). When +/// [existing] is given its id and enabled state are kept; otherwise a new id +/// is generated. [initialPattern] and [initialField] prefill a new rule, for +/// example "Filter messages like this…" from a chat message. +Future showFilterRuleDialog( + BuildContext context, { + FilterRule? existing, + String? initialPattern, + FilterRuleField? initialField, +}) { + return showDialog( + context: context, + builder: (_) => _FilterRuleDialog( + existing: existing, + initialPattern: initialPattern, + initialField: initialField, + ), + ); +} + +class _FilterRuleDialog extends StatefulWidget { + final FilterRule? existing; + final String? initialPattern; + final FilterRuleField? initialField; + + const _FilterRuleDialog({ + this.existing, + this.initialPattern, + this.initialField, + }); + + @override + State<_FilterRuleDialog> createState() => _FilterRuleDialogState(); +} + +class _FilterRuleDialogState extends State<_FilterRuleDialog> { + late final TextEditingController _controller; + late FilterRuleField _field; + late FilterRuleMatch _match; + + @override + void initState() { + super.initState(); + final existing = widget.existing; + final pattern = (existing?.pattern ?? widget.initialPattern ?? '').trim(); + _controller = TextEditingController(text: pattern) + ..selection = TextSelection.collapsed(offset: pattern.length); + _field = existing?.field ?? widget.initialField ?? FilterRuleField.text; + _match = existing?.match ?? FilterRuleMatch.contains; + } + + @override + void dispose() { + _controller.dispose(); + super.dispose(); + } + + bool get _canSave => _controller.text.trim().isNotEmpty; + + void _save() { + if (!_canSave) return; + final existing = widget.existing; + final pattern = _controller.text.trim(); + final rule = existing != null + ? existing.copyWith(pattern: pattern, field: _field, match: _match) + : FilterRule( + id: MessageFilterService.newRuleId(), + pattern: pattern, + field: _field, + match: _match, + ); + Navigator.of(context).pop(rule); + } + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final theme = Theme.of(context); + final labelStyle = theme.textTheme.titleSmall?.copyWith( + fontWeight: FontWeight.w600, + color: theme.colorScheme.onSurfaceVariant, + ); + + return AlertDialog( + title: Text( + widget.existing == null + ? l10n.messageFilter_addRule + : l10n.messageFilter_editRule, + ), + contentPadding: const EdgeInsets.fromLTRB(24, 16, 24, 0), + content: SizedBox( + width: 420, + child: SingleChildScrollView( + child: Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + TextField( + controller: _controller, + autofocus: true, + minLines: 1, + maxLines: 4, + textInputAction: TextInputAction.done, + style: theme.textTheme.bodyLarge, + decoration: InputDecoration( + labelText: l10n.messageFilter_rulePattern, + hintText: l10n.messageFilter_rulePatternHint, + border: const OutlineInputBorder(), + ), + onChanged: (_) => setState(() {}), + onSubmitted: (_) => _save(), + ), + const SizedBox(height: 20), + Text(l10n.messageFilter_ruleWhere, style: labelStyle), + RadioGroup( + groupValue: _field, + onChanged: (value) { + if (value != null) setState(() => _field = value); + }, + child: Column( + children: [ + for (final field in FilterRuleField.values) + RadioListTile( + key: ValueKey('filterRuleField_${field.name}'), + value: field, + contentPadding: EdgeInsets.zero, + title: Text(filterRuleFieldLabel(context, field)), + ), + ], + ), + ), + const SizedBox(height: 12), + Text(l10n.messageFilter_ruleMatch, style: labelStyle), + RadioGroup( + groupValue: _match, + onChanged: (value) { + if (value != null) setState(() => _match = value); + }, + child: Column( + children: [ + for (final match in FilterRuleMatch.values) + RadioListTile( + key: ValueKey('filterRuleMatch_${match.name}'), + value: match, + contentPadding: EdgeInsets.zero, + title: Text(filterRuleMatchLabel(context, match)), + ), + ], + ), + ), + ], + ), + ), + ), + actions: [ + TextButton( + onPressed: () => Navigator.of(context).pop(), + child: Text(l10n.common_cancel), + ), + FilledButton( + onPressed: _canSave ? _save : null, + child: Text(l10n.common_save), + ), + ], + ); + } +} + +/// User-facing name for where a rule looks ("Message text", "Sender name", +/// "Both"). +String filterRuleFieldLabel(BuildContext context, FilterRuleField field) { + final l10n = context.l10n; + return switch (field) { + FilterRuleField.text => l10n.messageFilter_ruleFieldText, + FilterRuleField.sender => l10n.messageFilter_ruleFieldSender, + FilterRuleField.both => l10n.messageFilter_ruleFieldBoth, + }; +} + +/// User-facing name for how a rule matches ("Contains", "Whole word", +/// "Exact"). +String filterRuleMatchLabel(BuildContext context, FilterRuleMatch match) { + final l10n = context.l10n; + return switch (match) { + FilterRuleMatch.contains => l10n.messageFilter_ruleMatchContains, + FilterRuleMatch.wholeWord => l10n.messageFilter_ruleMatchWholeWord, + FilterRuleMatch.exact => l10n.messageFilter_ruleMatchExact, + }; +} diff --git a/lib/widgets/filtered_message_ghost.dart b/lib/widgets/filtered_message_ghost.dart new file mode 100644 index 00000000..160ca59b --- /dev/null +++ b/lib/widgets/filtered_message_ghost.dart @@ -0,0 +1,396 @@ +import 'package:flutter/material.dart'; + +import '../l10n/app_localizations.dart'; +import '../l10n/l10n.dart'; +import '../models/message_filter.dart'; +import '../theme/mesh_theme.dart'; + +/// Localized "Filtered: …" line for a message the filter hid. +/// +/// [reason] is the stored `ChannelMessage.filterReason` (a [FilterReason] +/// JSON name); [detail] the matching rule pattern for rule hits, shortened +/// (see [shortFilterDetail]) so a rule made from a whole spam message never +/// spells that message out. An unknown or missing reason falls back to the +/// generic manual wording. +String messageFilterReasonLabel( + AppLocalizations l10n, + String? reason, + String? detail, +) { + switch (filterReasonFromJson(reason)) { + case FilterReason.textRule: + return l10n.messageFilter_reasonTextRule(shortFilterDetail(detail)); + case FilterReason.senderRule: + return l10n.messageFilter_reasonSenderRule(shortFilterDetail(detail)); + case FilterReason.repeatedCharacters: + return l10n.messageFilter_reasonRepeatedCharacters; + case FilterReason.duplicate: + return l10n.messageFilter_reasonDuplicate; + case FilterReason.crossSenderDuplicate: + return l10n.messageFilter_reasonCrossSenderDuplicate; + case FilterReason.learned: + return l10n.messageFilter_reasonLearned; + case FilterReason.manual: + case null: + return l10n.messageFilter_reasonManual; + } +} + +/// Longest rule pattern shown in a reason line, in characters. +const int filterDetailMaxLength = 24; + +/// [detail] on one line, cut to [filterDetailMaxLength] characters plus an +/// ellipsis. +String shortFilterDetail(String? detail) { + final oneLine = (detail ?? '').trim().replaceAll(RegExp(r'\s+'), ' '); + final chars = oneLine.characters; + if (chars.length <= filterDetailMaxLength) return oneLine; + return '${chars.take(filterDetailMaxLength).toString().trimRight()}…'; +} + +/// Low-emphasis stand-in for one or more messages hidden by the message +/// filter. +/// +/// Deliberately smaller and quieter than a message bubble, and never shows +/// the hidden text or sender — only how many messages there are and why the +/// newest was hidden. The whole row is one tap target (at least 48dp tall) +/// that reveals the run. +class FilteredMessageGhost extends StatelessWidget { + /// Number of hidden messages this row stands for (at least 1). + final int count; + + /// Why the newest hidden message was filtered, already localized. + final String reason; + + /// Chat text scale, so the row grows with the bubbles around it. + final double textScale; + + /// The run is revealed and this row is the header above it: tapping hides + /// the messages again. + final bool expanded; + + final VoidCallback onTap; + + const FilteredMessageGhost({ + super.key, + required this.count, + required this.reason, + required this.onTap, + this.textScale = 1.0, + this.expanded = false, + }); + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final scheme = Theme.of(context).colorScheme; + final muted = scheme.onSurfaceVariant; + final title = expanded + ? (count <= 1 + ? l10n.messageFilter_ghostSingleExpanded + : l10n.messageFilter_ghostManyExpanded(count)) + : (count <= 1 + ? l10n.messageFilter_ghostSingle + : l10n.messageFilter_ghostMany(count)); + final radius = BorderRadius.circular(MeshRadii.md); + + return Padding( + padding: const EdgeInsets.symmetric(vertical: 3), + child: Align( + alignment: AlignmentDirectional.centerStart, + child: ConstrainedBox( + constraints: const BoxConstraints(maxWidth: 420), + child: Semantics( + button: true, + // Only announce an expanded state on the header of a revealed run. + expanded: expanded ? true : null, + label: '$title. $reason', + // excludeSemantics drops the InkWell's tap action, so expose it + // here for screen readers. + onTap: onTap, + excludeSemantics: true, + child: Material( + color: scheme.surfaceContainerLow.withValues(alpha: 0.85), + shape: RoundedRectangleBorder( + borderRadius: radius, + side: BorderSide(color: scheme.outlineVariant), + ), + clipBehavior: Clip.antiAlias, + child: InkWell( + onTap: onTap, + child: ConstrainedBox( + constraints: const BoxConstraints(minHeight: 48), + child: Padding( + padding: const EdgeInsets.symmetric( + horizontal: 12, + vertical: 6, + ), + child: Row( + mainAxisSize: MainAxisSize.min, + children: [ + Tooltip( + message: l10n.messageFilter_ghostIconTooltip, + child: AnimatedSwitcher( + duration: _ghostSwapDuration(context), + child: Icon( + expanded + ? Icons.expand_less + : Icons.visibility_off_outlined, + key: ValueKey(expanded), + size: 18 * textScale, + color: muted, + ), + ), + ), + const SizedBox(width: 10), + Flexible( + child: Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + AnimatedSwitcher( + duration: _ghostSwapDuration(context), + layoutBuilder: (current, previous) => Stack( + alignment: AlignmentDirectional.centerStart, + children: [...previous, ?current], + ), + child: Text( + title, + key: ValueKey(title), + style: TextStyle( + fontSize: 14 * textScale, + fontWeight: FontWeight.w600, + color: muted, + ), + ), + ), + const SizedBox(height: 1), + Text( + reason, + maxLines: 1, + overflow: TextOverflow.ellipsis, + style: TextStyle( + fontSize: 13 * textScale, + color: muted, + ), + ), + ], + ), + ), + ], + ), + ), + ), + ), + ), + ), + ), + ), + ); + } +} + +/// Cross-fade time for the ghost row's icon and title when a run opens or +/// closes; zero when the platform asks for reduced motion. +Duration _ghostSwapDuration(BuildContext context) => + MediaQuery.maybeDisableAnimationsOf(context) ?? false + ? Duration.zero + : const Duration(milliseconds: 180); + +/// How long a run of hidden messages takes to open or close. +const Duration filteredRunAnimationDuration = Duration(milliseconds: 250); + +/// A run of messages hidden by the filter, shown as one [FilteredMessageGhost] +/// header with the messages underneath it. +/// +/// Toggling [expanded] animates the messages open (unrolling below the header +/// with a fade) or closed again, in place, so the run never jumps around the +/// chat. Messages are only built while some of them are visible. With reduced +/// motion turned on the change is instant. +class FilteredMessageRun extends StatefulWidget { + /// Number of hidden messages in the run (at least 1). + final int count; + + /// Why the newest message was hidden, already localized. + final String reason; + + final double textScale; + + /// Whether the run's messages are shown. + final bool expanded; + + /// Called when the header is tapped (open when collapsed, close when open). + final VoidCallback onToggle; + + /// Builds the run's message bubbles, oldest first (top to bottom). + final List Function(BuildContext context) buildMessages; + + const FilteredMessageRun({ + super.key, + required this.count, + required this.reason, + required this.expanded, + required this.onToggle, + required this.buildMessages, + this.textScale = 1.0, + }); + + @override + State createState() => _FilteredMessageRunState(); +} + +class _FilteredMessageRunState extends State + with SingleTickerProviderStateMixin { + late final AnimationController _controller = AnimationController( + vsync: this, + duration: filteredRunAnimationDuration, + value: widget.expanded ? 1.0 : 0.0, + ); + late final CurvedAnimation _curve = CurvedAnimation( + parent: _controller, + curve: Curves.easeInOutCubic, + ); + + @override + void didUpdateWidget(FilteredMessageRun oldWidget) { + super.didUpdateWidget(oldWidget); + if (oldWidget.expanded == widget.expanded) return; + final reduceMotion = MediaQuery.maybeDisableAnimationsOf(context) ?? false; + if (reduceMotion) { + _controller.value = widget.expanded ? 1.0 : 0.0; + } else if (widget.expanded) { + _controller.forward(); + } else { + _controller.reverse(); + } + } + + @override + void dispose() { + _curve.dispose(); + _controller.dispose(); + super.dispose(); + } + + @override + Widget build(BuildContext context) { + return Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + FilteredMessageGhost( + count: widget.count, + reason: widget.reason, + textScale: widget.textScale, + expanded: widget.expanded, + onTap: widget.onToggle, + ), + AnimatedBuilder( + animation: _curve, + builder: (context, _) { + if (_controller.isDismissed) return const SizedBox.shrink(); + return ClipRect( + child: Align( + alignment: Alignment.topCenter, + heightFactor: _curve.value, + child: Opacity( + opacity: _curve.value, + child: Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.stretch, + children: widget.buildMessages(context), + ), + ), + ), + ); + }, + ), + ], + ); + } +} + +/// Slim, calm banner shown inside a revealed filtered message's bubble, above +/// its text: why it was hidden, plus "Not spam" and "Hide". +class FilteredMessageBanner extends StatelessWidget { + final String reason; + final double textScale; + + /// Text colour of the surrounding bubble; the banner derives its muted + /// tones from it so it reads on both incoming and themed bubbles. + final Color color; + final VoidCallback onNotSpam; + final VoidCallback onHide; + + const FilteredMessageBanner({ + super.key, + required this.reason, + required this.color, + required this.onNotSpam, + required this.onHide, + this.textScale = 1.0, + }); + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + final muted = color.withValues(alpha: 0.78); + final buttonStyle = TextButton.styleFrom( + foregroundColor: color, + minimumSize: const Size(48, 48), + tapTargetSize: MaterialTapTargetSize.padded, + padding: const EdgeInsets.symmetric(horizontal: 10), + textStyle: TextStyle( + fontSize: 13 * textScale, + fontWeight: FontWeight.w600, + ), + ); + return Container( + margin: const EdgeInsets.only(bottom: 6), + padding: const EdgeInsets.fromLTRB(8, 4, 2, 2), + decoration: BoxDecoration( + color: color.withValues(alpha: 0.06), + borderRadius: BorderRadius.circular(MeshRadii.sm), + border: Border.all(color: color.withValues(alpha: 0.18)), + ), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + mainAxisSize: MainAxisSize.min, + children: [ + Row( + mainAxisSize: MainAxisSize.min, + children: [ + Icon( + Icons.visibility_off_outlined, + size: 16 * textScale, + color: muted, + ), + const SizedBox(width: 6), + Flexible( + child: Text( + reason, + style: TextStyle(fontSize: 13 * textScale, color: muted), + ), + ), + ], + ), + Wrap( + spacing: 4, + children: [ + TextButton( + style: buttonStyle, + onPressed: onNotSpam, + child: Text(l10n.messageFilter_notSpam), + ), + TextButton( + style: buttonStyle, + onPressed: onHide, + child: Text(l10n.messageFilter_hideAgain), + ), + ], + ), + ], + ), + ); + } +} diff --git a/test/connector/message_filter_ingest_test.dart b/test/connector/message_filter_ingest_test.dart new file mode 100644 index 00000000..acf28cb0 --- /dev/null +++ b/test/connector/message_filter_ingest_test.dart @@ -0,0 +1,374 @@ +import 'dart:convert'; +import 'dart:typed_data'; + +import 'package:crypto/crypto.dart' as crypto; +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/connector/meshcore_connector.dart'; +import 'package:meshcore_open/connector/meshcore_protocol.dart'; +import 'package:meshcore_open/models/channel.dart'; +import 'package:meshcore_open/models/channel_message.dart'; +import 'package:meshcore_open/models/message_filter.dart'; +import 'package:meshcore_open/review_mode/review_frames.dart'; +import 'package:meshcore_open/review_mode/review_radio.dart'; +import 'package:meshcore_open/review_mode/review_script.dart'; +import 'package:meshcore_open/services/message_filter/message_filter_service.dart'; +import 'package:meshcore_open/services/message_retry_service.dart'; +import 'package:meshcore_open/services/path_history_service.dart'; +import 'package:meshcore_open/services/storage_service.dart'; +import 'package:meshcore_open/storage/prefs_manager.dart'; +import 'package:pointycastle/export.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +Future _waitFor(bool Function() condition, {int seconds = 8}) async { + final end = DateTime.now().add(Duration(seconds: seconds)); + while (!condition()) { + if (DateTime.now().isAfter(end)) fail('Timed out waiting for condition'); + await Future.delayed(const Duration(milliseconds: 20)); + } +} + +Uint8List _psk(int slot) => + Channel.parsePskHex(ReviewScript.channels[slot].pskHex); + +class _TestRadio extends ReviewRadio { + _TestRadio() + : super( + scheduledMessageInterval: const Duration(hours: 1), + ackDelay: const Duration(milliseconds: 50), + replyDelay: const Duration(hours: 1), + ); +} + +Uint8List _logRxGroupText(Uint8List psk, String text, int timestampSecs) { + final plain = BytesBuilder() + ..add( + Uint8List(4) + ..buffer.asByteData().setUint32(0, timestampSecs, Endian.little), + ) + ..addByte(0) + ..add(utf8.encode(text)) + ..addByte(0); + final padded = Uint8List(((plain.length + 15) ~/ 16) * 16) + ..setRange(0, plain.length, plain.toBytes()); + final cipher = ECBBlockCipher(AESEngine())..init(true, KeyParameter(psk)); + final encrypted = Uint8List(padded.length); + for (var i = 0; i < padded.length; i += 16) { + cipher.processBlock(padded, i, encrypted, i); + } + final key32 = Uint8List(32)..setRange(0, 16, psk); + final mac = crypto.Hmac(crypto.sha256, key32).convert(encrypted).bytes; + final channelHash = crypto.sha256.convert(psk).bytes[0]; + return Uint8List.fromList([ + pushCodeLogRxData, + 40, // snr + 0xA0, // rssi + 0x15, // flood route, GRP_TXT payload + 0x00, // no path + channelHash, + mac[0], + mac[1], + ...encrypted, + ]); +} + +late MeshCoreConnector _connector; +late MessageFilterService _filter; + +Future _connect() async { + final radio = _TestRadio(); + _connector.reviewRadioFactoryForTest = () => radio; + await _connector.connectReview(); + addTearDown(_connector.disconnect); + await _waitFor(() => _connector.channelMapConfirmed); +} + +Channel _channelAt(int slot) => + _connector.channels.firstWhere((c) => c.index == slot); + +ChannelMessage? _find(int slot, String text) { + for (final m in _connector.getChannelMessages(_channelAt(slot))) { + if (m.text == text) return m; + } + return null; +} + +int _nowSecs() => DateTime.now().millisecondsSinceEpoch ~/ 1000; + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + + setUpAll(() async { + SharedPreferences.setMockInitialValues({}); + PrefsManager.reset(); + await PrefsManager.initialize(); + _filter = MessageFilterService(); + await _filter.load(); + await _filter.addRule( + FilterRule(id: MessageFilterService.newRuleId(), pattern: 'meshos'), + ); + _connector = MeshCoreConnector(); + final retryService = MessageRetryService(); + _connector.initialize( + retryService: retryService, + pathHistoryService: PathHistoryService(StorageService()), + messageFilterService: _filter, + ); + addTearDown(() { + _connector.dispose(); + retryService.dispose(); + _filter.dispose(); + }); + }); + + test('applyFilterVerdict tags the message, or leaves it alone', () { + final message = ChannelMessage( + senderKey: null, + senderName: 'Sam', + text: 'hello', + timestamp: DateTime(2026), + isOutgoing: false, + status: ChannelMessageStatus.sent, + ); + expect( + identical(MeshCoreConnector.applyFilterVerdict(message, null), message), + isTrue, + ); + final tagged = MeshCoreConnector.applyFilterVerdict( + message, + const FilterVerdict(reason: FilterReason.textRule, detail: 'meshos'), + ); + expect(tagged.isFiltered, isTrue); + expect(tagged.filterReason, 'textRule'); + expect(tagged.filterDetail, 'meshos'); + }); + + test('a channel message matching a rule is stored tagged and does not ' + 'count as unread', () async { + await _connect(); + final channel = _channelAt(2); + final unreadBefore = channel.unreadCount; + + _connector.handleFrameForTest( + ReviewFrames.channelMessage( + channelIndex: 2, + sender: 'Spammer', + message: 'Try MeshOS today, free download', + timestampSecs: _nowSecs(), + ), + ); + _connector.handleFrameForTest( + ReviewFrames.channelMessage( + channelIndex: 2, + sender: 'Sam', + message: 'Anyone up for a hike on Sunday?', + timestampSecs: _nowSecs() + 1, + ), + ); + await _waitFor(() => _find(2, 'Anyone up for a hike on Sunday?') != null); + + final spam = _find(2, 'Try MeshOS today, free download')!; + expect(spam.filterReason, filterReasonToJson(FilterReason.textRule)); + expect(spam.filterDetail, 'meshos'); + final clean = _find(2, 'Anyone up for a hike on Sunday?')!; + expect(clean.isFiltered, isFalse); + // Only the clean message counts as unread. + expect(channel.unreadCount, unreadBefore + 1); + + expect(_connector.latestVisibleChannelMessage(channel)?.text, clean.text); + final filtered = _connector.recentFilteredChannelMessages(); + expect(filtered.map((e) => e.$2.messageId), contains(spam.messageId)); + expect( + filtered.firstWhere((e) => e.$2.messageId == spam.messageId).$1.index, + 2, + ); + }); + + test('an RX-log message matching a rule is stored tagged', () async { + await _connect(); + final channel = _channelAt(2); + final unreadBefore = channel.unreadCount; + _connector.handleFrameForTest( + _logRxGroupText(_psk(2), 'Bot: get meshos now', _nowSecs()), + ); + await _waitFor(() => _find(2, 'get meshos now') != null); + final message = _find(2, 'get meshos now')!; + expect(message.filterReason, filterReasonToJson(FilterReason.textRule)); + expect(channel.unreadCount, unreadBefore); + expect( + _connector.latestVisibleChannelMessage(channel)?.text, + isNot('get meshos now'), + ); + }); + + test('mark spam and not spam update the stored message', () async { + await _connect(); + const text = 'Selling radios cheap, message me'; + _connector.handleFrameForTest( + ReviewFrames.channelMessage( + channelIndex: 2, + sender: 'Trader', + message: text, + timestampSecs: _nowSecs(), + ), + ); + await _waitFor(() => _find(2, text) != null); + final message = _find(2, text)!; + expect(message.isFiltered, isFalse); + final spamBefore = _filter.spamExampleCount; + + await _connector.markChannelMessageSpam(_channelAt(2), message); + expect(_find(2, text)!.filterReason, 'manual'); + expect(_find(2, text)!.filterDetail, isNull); + expect(_filter.spamExampleCount, spamBefore + 1); + + final notSpamBefore = _filter.notSpamExampleCount; + await _connector.markChannelMessageNotSpam(_channelAt(2), _find(2, text)!); + expect(_find(2, text)!.isFiltered, isFalse); + expect(_filter.notSpamExampleCount, notSpamBefore + 1); + }); + + test('spam on a reply whose target is not loaded replaces its clean ' + 'example', () async { + await _connect(); + // Nobody called "Ghost" has posted, so the reply keeps its mention. + const text = '@[Ghost] cheap radios for sale, message me today'; + final cleanBefore = _filter.recentCleanCount; + _connector.handleFrameForTest( + ReviewFrames.channelMessage( + channelIndex: 2, + sender: 'Seller', + message: text, + timestampSecs: _nowSecs(), + ), + ); + await _waitFor(() => _find(2, text) != null); + final message = _find(2, text)!; + expect(message.text, startsWith('@[Ghost]')); + expect(_filter.recentCleanCount, cleanBefore + 1); + + final spamBefore = _filter.spamExampleCount; + await _connector.markChannelMessageSpam(_channelAt(2), message); + expect(_filter.spamExampleCount, spamBefore + 1); + // The clean example recorded on arrival is gone, not contradicted. + expect(_filter.recentCleanCount, cleanBefore); + }); + + test('spam actions only touch the message in the chosen channel', () async { + await _connect(); + // Any two configured channels. + final channels = _connector.channels.where((c) => !c.isEmpty).toList(); + expect(channels.length, greaterThanOrEqualTo(2)); + final first = channels[0]; + final second = channels[1]; + const text = 'Same words posted to two channels at once'; + final ts = _nowSecs(); + for (final channel in [first, second]) { + _connector.handleFrameForTest( + ReviewFrames.channelMessage( + channelIndex: channel.index, + sender: 'Twin', + message: text, + timestampSecs: ts, + ), + ); + } + await _waitFor( + () => + _find(first.index, text) != null && _find(second.index, text) != null, + ); + final inFirst = _find(first.index, text)!; + final inSecond = _find(second.index, text)!; + // Message ids do not include the channel, so these collide. + expect(inSecond.messageId, inFirst.messageId); + + await _connector.markChannelMessageSpam(second, inSecond); + expect(_find(second.index, text)!.filterReason, 'manual'); + expect(_find(first.index, text)!.isFiltered, isFalse); + + // Not spam on the first channel must not un-hide the second. + await _connector.markChannelMessageSpam(first, _find(first.index, text)!); + await _connector.markChannelMessageNotSpam( + first, + _find(first.index, text)!, + ); + expect(_find(first.index, text)!.isFiltered, isFalse); + expect(_find(second.index, text)!.filterReason, 'manual'); + }); + + test('channels excluded from filtering keep every message visible', () async { + await _connect(); + final channel = _channelAt(2); + await _filter.setChannelExcluded( + MeshCoreConnector.messageFilterChannelId(channel), + true, + ); + addTearDown( + () => _filter.setChannelExcluded( + MeshCoreConnector.messageFilterChannelId(channel), + false, + ), + ); + _connector.handleFrameForTest( + ReviewFrames.channelMessage( + channelIndex: 2, + sender: 'Spammer', + message: 'meshos in an excluded channel', + timestampSecs: _nowSecs(), + ), + ); + await _waitFor(() => _find(2, 'meshos in an excluded channel') != null); + expect(_find(2, 'meshos in an excluded channel')!.isFiltered, isFalse); + }); + + test( + 'an exact rule matches a reply by its text without the mention', + () async { + await _connect(); + const text = 'exact spam phrase here'; + await _filter.addRule( + const FilterRule( + id: 'exact-reply', + pattern: text, + match: FilterRuleMatch.exact, + ), + ); + addTearDown(() => _filter.removeRule('exact-reply')); + _connector.handleFrameForTest( + ReviewFrames.channelMessage( + channelIndex: 2, + sender: 'Replier', + message: '@[Sam] $text', + timestampSecs: _nowSecs(), + ), + ); + // The stored text drops the mention only when the reply target is + // known; either way the rule sees the text without it. + ChannelMessage? reply() => _find(2, text) ?? _find(2, '@[Sam] $text'); + await _waitFor(() => reply() != null); + expect(reply()!.filterReason, 'textRule'); + }, + ); + + test('previews include filtered messages when the channel is not ' + 'filtered', () async { + await _connect(); + final channel = _channelAt(2); + const text = 'meshos preview check'; + _connector.handleFrameForTest( + ReviewFrames.channelMessage( + channelIndex: 2, + sender: 'Spammer', + message: text, + timestampSecs: _nowSecs() + 5, + ), + ); + await _waitFor(() => _find(2, text) != null); + expect(_find(2, text)!.isFiltered, isTrue); + expect(_connector.latestVisibleChannelMessage(channel)?.text, isNot(text)); + + final channelId = MeshCoreConnector.messageFilterChannelId(channel); + await _filter.setChannelExcluded(channelId, true); + addTearDown(() => _filter.setChannelExcluded(channelId, false)); + expect(_connector.latestVisibleChannelMessage(channel)?.text, text); + }); +} diff --git a/test/models/channel_message_filter_test.dart b/test/models/channel_message_filter_test.dart new file mode 100644 index 00000000..3b45b7e1 --- /dev/null +++ b/test/models/channel_message_filter_test.dart @@ -0,0 +1,57 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/models/channel_message.dart'; +import 'package:meshcore_open/storage/channel_message_store.dart'; +import 'package:meshcore_open/storage/prefs_manager.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +ChannelMessage _msg({String? reason, String? detail}) => ChannelMessage( + senderName: 'Alice', + text: 'hello', + timestamp: DateTime.fromMillisecondsSinceEpoch(1000), + isOutgoing: false, + messageId: 'm1', + filterReason: reason, + filterDetail: detail, +); + +void main() { + test('isFiltered reflects filterReason', () { + expect(_msg().isFiltered, isFalse); + expect(_msg(reason: 'manual').isFiltered, isTrue); + }); + + test('copyWith sets, keeps and clears filter fields', () { + final filtered = _msg().copyWith( + filterReason: 'textRule', + filterDetail: 'spam', + ); + expect(filtered.filterReason, 'textRule'); + expect(filtered.filterDetail, 'spam'); + final kept = filtered.copyWith(repeatCount: 2); + expect(kept.filterReason, 'textRule'); + expect(kept.filterDetail, 'spam'); + final cleared = filtered.copyWith(clearFilter: true); + expect(cleared.isFiltered, isFalse); + expect(cleared.filterDetail, isNull); + }); + + test('store round-trips filter fields and omits them when null', () async { + SharedPreferences.setMockInitialValues({}); + PrefsManager.reset(); + await PrefsManager.initialize(); + final store = ChannelMessageStore()..setPublicKeyHex = 'abcdef012345'; + store.forgetArchive(); + await store.saveChannelMessages('c1', [ + _msg(reason: 'textRule', detail: 'spam'), + ]); + var loaded = await store.loadChannelMessages('c1'); + expect(loaded.single.filterReason, 'textRule'); + expect(loaded.single.filterDetail, 'spam'); + + store.forgetArchive(); + await store.saveChannelMessages('c2', [_msg()]); + loaded = await store.loadChannelMessages('c2'); + expect(loaded.single.filterReason, isNull); + expect(loaded.single.filterDetail, isNull); + }); +} diff --git a/test/screens/channel_chat_transcript_grouping_test.dart b/test/screens/channel_chat_transcript_grouping_test.dart new file mode 100644 index 00000000..e10d803c --- /dev/null +++ b/test/screens/channel_chat_transcript_grouping_test.dart @@ -0,0 +1,280 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/models/message_filter.dart'; +import 'package:meshcore_open/screens/channel_chat_transcript_grouping.dart'; + +final _day1 = DateTime(2026, 3, 1, 12); +final _day2 = DateTime(2026, 3, 2, 12); + +TranscriptRowInfo _msg(String id, {bool filtered = false, DateTime? at}) => + TranscriptRowInfo(id: id, receivedAt: at ?? _day1, isFiltered: filtered); + +TranscriptRowInfo _img(String id, {bool filtered = false}) => TranscriptRowInfo( + id: id, + receivedAt: _day1, + isImage: true, + isFiltered: filtered, +); + +bool _sameDay(DateTime a, DateTime b) => + a.year == b.year && a.month == b.month && a.day == b.day; + +/// Compact description: plain rows by id, ghosts as `[ids]`, the header above +/// a revealed run as `^[ids]`. +List _describe( + List rows, + List entries, +) => [ + for (final e in entries) + e.isGhost + ? '${e.expanded ? '^' : ''}[${e.rows.map((r) => rows[r].id).join(',')}]' + : rows[e.row].id, +]; + +void main() { + group('groupFilteredRows', () { + test('no filtered rows leaves every row as its own entry', () { + final rows = [_msg('a'), _msg('b'), _msg('c')]; + final entries = groupFilteredRows( + rows, + mode: FilterDisplayMode.placeholder, + ); + expect(_describe(rows, entries), ['a', 'b', 'c']); + expect(entries.every((e) => !e.isGhost), isTrue); + }); + + test('placeholder mode collapses each run into one ghost', () { + final rows = [ + _msg('a'), + _msg('s1', filtered: true), + _msg('s2', filtered: true), + _msg('s3', filtered: true), + _msg('b'), + _msg('s4', filtered: true), + ]; + final entries = groupFilteredRows( + rows, + mode: FilterDisplayMode.placeholder, + ); + expect(_describe(rows, entries), ['a', '[s1,s2,s3]', 'b', '[s4]']); + // The ghost id follows its newest member (first in newest-first order). + expect(entries[1].id, 'ghost:s1'); + expect(entries[3].id, 'ghost:s4'); + expect(entries[0].id, 'a'); + }); + + test('hide mode drops filtered rows entirely', () { + final rows = [ + _msg('a'), + _msg('s1', filtered: true), + _msg('s2', filtered: true), + _msg('b'), + ]; + final entries = groupFilteredRows(rows, mode: FilterDisplayMode.hide); + expect(_describe(rows, entries), ['a', 'b']); + }); + + test( + 'revealed ids render as normal rows under a header and split runs', + () { + final rows = [ + _msg('s1', filtered: true), + _msg('s2', filtered: true), + _msg('s3', filtered: true), + ]; + final entries = groupFilteredRows( + rows, + mode: FilterDisplayMode.placeholder, + revealedIds: {'s2'}, + ); + expect(_describe(rows, entries), ['[s1]', '^[s2]', '[s3]']); + + final hidden = groupFilteredRows( + rows, + mode: FilterDisplayMode.hide, + revealedIds: {'s2'}, + ); + expect(_describe(rows, hidden), ['s2']); + }, + ); + + test('a fully revealed run stays one entry with a stable id', () { + final rows = [ + _msg('a'), + _msg('s1', filtered: true), + _msg('s2', filtered: true), + _msg('s3', filtered: true), + _msg('b'), + ]; + final collapsed = groupFilteredRows( + rows, + mode: FilterDisplayMode.placeholder, + ); + final expanded = groupFilteredRows( + rows, + mode: FilterDisplayMode.placeholder, + revealedIds: {'s1', 's2', 's3'}, + ); + expect(_describe(rows, expanded), ['a', '^[s1,s2,s3]', 'b']); + // Same id in both states, so the UI can animate it in place. + expect(expanded[1].id, collapsed[1].id); + expect(expanded[1].id, 'ghost:s1'); + expect(collapsed[1].expanded, isFalse); + expect(expanded[1].expanded, isTrue); + // Scroll targets inside the run land on the run entry. + final byRow = entryIndexByRow(expanded, rows.length); + expect([for (var r = 0; r < rows.length; r++) byRow[r]], [0, 1, 1, 1, 2]); + }); + + test('images are never grouped and break a run', () { + final rows = [ + _msg('s1', filtered: true), + _img('aeic:1', filtered: true), + _msg('s2', filtered: true), + ]; + final entries = groupFilteredRows( + rows, + mode: FilterDisplayMode.placeholder, + ); + expect(_describe(rows, entries), ['[s1]', 'aeic:1', '[s2]']); + expect( + _describe(rows, groupFilteredRows(rows, mode: FilterDisplayMode.hide)), + ['aeic:1'], + ); + }); + + test('inactive filter shows filtered messages as normal rows', () { + final rows = [_msg('s1', filtered: true), _msg('a')]; + final entries = groupFilteredRows( + rows, + mode: FilterDisplayMode.hide, + filterActive: false, + ); + expect(_describe(rows, entries), ['s1', 'a']); + }); + + test('a run is split at a day boundary when sameDay is given', () { + final rows = [ + _msg('s1', filtered: true, at: _day2), + _msg('s2', filtered: true, at: _day1), + _msg('s3', filtered: true, at: _day1), + ]; + expect( + _describe( + rows, + groupFilteredRows( + rows, + mode: FilterDisplayMode.placeholder, + sameDay: _sameDay, + ), + ), + ['[s1]', '[s2,s3]'], + ); + expect( + _describe( + rows, + groupFilteredRows(rows, mode: FilterDisplayMode.placeholder), + ), + ['[s1,s2,s3]'], + ); + }); + + test('empty input yields no entries', () { + expect( + groupFilteredRows(const [], mode: FilterDisplayMode.placeholder), + isEmpty, + ); + }); + }); + + group('entryIndexByRow', () { + test('an unread anchor inside a ghost run maps to the ghost', () { + final rows = [ + _msg('new'), + _msg('s1', filtered: true), + _msg('anchor', filtered: true), + _msg('old'), + ]; + final entries = groupFilteredRows( + rows, + mode: FilterDisplayMode.placeholder, + ); + final byRow = entryIndexByRow(entries, rows.length); + expect(byRow[2], 1); + expect(entries[byRow[2]!].id, 'ghost:s1'); + expect(byRow[0], 0); + expect(byRow[3], 2); + }); + + test('a row dropped in hide mode maps to the nearest newer entry', () { + final rows = [ + _msg('new'), + _msg('s1', filtered: true), + _msg('s2', filtered: true), + _msg('old'), + ]; + final entries = groupFilteredRows(rows, mode: FilterDisplayMode.hide); + final byRow = entryIndexByRow(entries, rows.length); + expect(entries[byRow[1]!].id, 'new'); + expect(entries[byRow[2]!].id, 'new'); + expect(entries[byRow[3]!].id, 'old'); + }); + + test('with nothing newer visible, hidden rows map to the older entry', () { + final rows = [ + _msg('s1', filtered: true), + _msg('s2', filtered: true), + _msg('old'), + ]; + final entries = groupFilteredRows(rows, mode: FilterDisplayMode.hide); + final byRow = entryIndexByRow(entries, rows.length); + expect(entries[byRow[0]!].id, 'old'); + expect(entries[byRow[1]!].id, 'old'); + }); + + test('maps nothing when every row is hidden', () { + final rows = [_msg('s1', filtered: true)]; + final entries = groupFilteredRows(rows, mode: FilterDisplayMode.hide); + expect(entryIndexByRow(entries, rows.length), isEmpty); + }); + }); + + group('isReplyPreviewConcealed', () { + test('hides a quoted filtered message until it is revealed', () { + expect( + isReplyPreviewConcealed( + quotedIsFiltered: true, + filterActive: true, + quotedRevealed: false, + ), + isTrue, + ); + expect( + isReplyPreviewConcealed( + quotedIsFiltered: true, + filterActive: true, + quotedRevealed: true, + ), + isFalse, + ); + }); + + test('normal quotes, or filtering off for the channel, show as usual', () { + expect( + isReplyPreviewConcealed( + quotedIsFiltered: false, + filterActive: true, + quotedRevealed: false, + ), + isFalse, + ); + expect( + isReplyPreviewConcealed( + quotedIsFiltered: true, + filterActive: false, + quotedRevealed: false, + ), + isFalse, + ); + }); + }); +} diff --git a/test/screens/filtered_messages_screen_helpers_test.dart b/test/screens/filtered_messages_screen_helpers_test.dart new file mode 100644 index 00000000..eb8bdca7 --- /dev/null +++ b/test/screens/filtered_messages_screen_helpers_test.dart @@ -0,0 +1,77 @@ +import 'dart:typed_data'; + +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/l10n/app_localizations.dart'; +import 'package:meshcore_open/models/channel.dart'; +import 'package:meshcore_open/models/channel_message.dart'; +import 'package:meshcore_open/screens/filtered_messages_screen.dart'; + +ChannelMessage _msg() => ChannelMessage( + senderName: 'Twin', + text: 'Same words posted to two channels at once', + timestamp: DateTime.fromMillisecondsSinceEpoch(1700000000000), + isOutgoing: false, +); + +void main() { + test('rows for colliding message ids in two channels stay distinct', () { + final first = Channel( + index: 1, + name: 'One', + psk: Uint8List.fromList(List.filled(16, 1)), + ); + final second = Channel( + index: 2, + name: 'Two', + psk: Uint8List.fromList(List.filled(16, 2)), + ); + final a = _msg(); + final b = _msg(); + // Message ids do not include the channel, so these collide... + expect(a.messageId, b.messageId); + // ...but the list rows (keys and reveal state) must not. + expect( + filteredMessageRowId(first, a), + isNot(filteredMessageRowId(second, b)), + ); + expect(filteredMessageRowId(first, a), filteredMessageRowId(first, b)); + }); + + testWidgets('collapsed cards shorten a whole-message rule pattern', ( + tester, + ) async { + const pattern = + 'meshcore.co.uk is not a genuine site, the real one is meshcore.io'; + final message = ChannelMessage( + senderName: 'SAY NO TO FRAUDS!', + text: pattern, + timestamp: DateTime.fromMillisecondsSinceEpoch(1700000000000), + isOutgoing: false, + filterReason: 'textRule', + filterDetail: pattern, + ); + late String collapsed; + late String revealed; + await tester.pumpWidget( + MaterialApp( + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + home: Builder( + builder: (context) { + collapsed = messageFilterReasonText(context, message); + revealed = messageFilterReasonText( + context, + message, + revealed: true, + ); + return const SizedBox(); + }, + ), + ), + ); + expect(collapsed, isNot(contains(pattern))); + expect(collapsed, contains('…')); + expect(revealed, contains(pattern)); + }); +} diff --git a/test/screens/message_filter_settings_screen_test.dart b/test/screens/message_filter_settings_screen_test.dart new file mode 100644 index 00000000..8da769b1 --- /dev/null +++ b/test/screens/message_filter_settings_screen_test.dart @@ -0,0 +1,239 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/connector/meshcore_connector.dart'; +import 'package:meshcore_open/l10n/app_localizations.dart'; +import 'package:meshcore_open/models/message_filter.dart'; +import 'package:meshcore_open/screens/filtered_messages_screen.dart'; +import 'package:meshcore_open/screens/message_filter_settings_screen.dart'; +import 'package:meshcore_open/services/message_filter/message_filter_service.dart'; +import 'package:meshcore_open/storage/message_filter_store.dart'; +import 'package:meshcore_open/storage/prefs_manager.dart'; +import 'package:meshcore_open/widgets/filter_rule_dialog.dart'; +import 'package:provider/provider.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +void main() { + late MessageFilterService service; + late MeshCoreConnector connector; + + setUp(() async { + SharedPreferences.setMockInitialValues({}); + PrefsManager.reset(); + await PrefsManager.initialize(); + service = MessageFilterService(store: MessageFilterStore()); + await service.load(); + connector = MeshCoreConnector(); + }); + + tearDown(() { + service.dispose(); + connector.dispose(); + }); + + Future pumpScreen(WidgetTester tester) async { + // Tall enough that every section is laid out without scrolling. + tester.view.physicalSize = const Size(1080, 4000); + tester.view.devicePixelRatio = 2.0; + addTearDown(tester.view.reset); + await tester.pumpWidget( + MultiProvider( + providers: [ + ChangeNotifierProvider.value(value: connector), + ChangeNotifierProvider.value(value: service), + ], + child: const MaterialApp( + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + home: MessageFilterSettingsScreen(), + ), + ), + ); + await tester.pumpAndSettle(); + } + + testWidgets('renders every section with defaults', (tester) async { + await pumpScreen(tester); + + expect(find.text('Message filter'), findsOneWidget); + expect(find.text('Filter messages'), findsOneWidget); + expect(find.text('Show a small placeholder'), findsOneWidget); + expect(find.text('Hide completely'), findsOneWidget); + expect( + find.text('Hidden messages stay in the Filtered messages list.'), + findsOneWidget, + ); + expect(find.text('Filtered messages (0)'), findsOneWidget); + expect( + find.text( + 'No rules yet. Add a word, phrase or sender name to hide messages ' + 'that match it.', + ), + findsOneWidget, + ); + expect(find.text('Repeated messages'), findsOneWidget); + expect(find.text('Repeated characters'), findsOneWidget); + expect(find.text('Learn from Spam taps'), findsOneWidget); + expect(find.text('0 spam and 0 not-spam examples'), findsOneWidget); + }); + + testWidgets('switches and display choice update the service', (tester) async { + await pumpScreen(tester); + + await tester.tap(find.byKey(const ValueKey('messageFilter_enabledSwitch'))); + await tester.pumpAndSettle(); + expect(service.settings.enabled, isFalse); + + await tester.tap(find.byKey(const ValueKey('messageFilter_displayHide'))); + await tester.pumpAndSettle(); + expect(service.settings.displayMode, FilterDisplayMode.hide); + + await tester.tap( + find.byKey(const ValueKey('messageFilter_duplicatesSwitch')), + ); + await tester.tap( + find.byKey(const ValueKey('messageFilter_repeatedCharactersSwitch')), + ); + await tester.tap( + find.byKey(const ValueKey('messageFilter_learningSwitch')), + ); + await tester.pumpAndSettle(); + expect(service.settings.duplicates, isFalse); + expect(service.settings.repeatedCharacters, isFalse); + expect(service.settings.learning, isFalse); + }); + + testWidgets('add, edit and delete a rule with undo', (tester) async { + await pumpScreen(tester); + + await tester.tap(find.byKey(const ValueKey('messageFilter_addRuleButton'))); + await tester.pumpAndSettle(); + expect(find.text('Add rule'), findsWidgets); + + // Save stays disabled until something is typed. + final saveButton = find.widgetWithText(FilledButton, 'Save'); + expect(tester.widget(saveButton).onPressed, isNull); + + await tester.enterText(find.byType(TextField), ' meshos '); + await tester.tap(find.byKey(const ValueKey('filterRuleField_both'))); + await tester.tap(find.byKey(const ValueKey('filterRuleMatch_wholeWord'))); + await tester.pumpAndSettle(); + await tester.tap(saveButton); + await tester.pumpAndSettle(); + + expect(service.rules, hasLength(1)); + final rule = service.rules.single; + expect(rule.pattern, 'meshos'); + expect(rule.field, FilterRuleField.both); + expect(rule.match, FilterRuleMatch.wholeWord); + expect(rule.enabled, isTrue); + expect(find.text('meshos'), findsOneWidget); + expect(find.text('Both · Whole word'), findsOneWidget); + expect(find.text('Rule saved'), findsOneWidget); + + // Turn it off from the list. + await tester.tap( + find.descendant( + of: find.byKey(ValueKey('messageFilter_rule_${rule.id}')), + matching: find.byType(Switch), + ), + ); + await tester.pumpAndSettle(); + expect(service.rules.single.enabled, isFalse); + + // Tap the row to edit; the id and enabled state are kept. + await tester.tap(find.text('meshos')); + await tester.pumpAndSettle(); + expect(find.text('Edit rule'), findsOneWidget); + await tester.enterText(find.byType(TextField), 'meshos promo'); + await tester.tap(find.widgetWithText(FilledButton, 'Save')); + await tester.pumpAndSettle(); + expect(service.rules.single.id, rule.id); + expect(service.rules.single.pattern, 'meshos promo'); + expect(service.rules.single.enabled, isFalse); + + // Delete, then undo. + await tester.tap(find.byTooltip('Delete')); + await tester.pumpAndSettle(); + expect(service.rules, isEmpty); + expect(find.text('Rule deleted'), findsOneWidget); + await tester.tap(find.text('Undo')); + await tester.pumpAndSettle(); + expect(service.rules.single.pattern, 'meshos promo'); + }); + + testWidgets('cancelling the dialog adds nothing', (tester) async { + await pumpScreen(tester); + await tester.tap(find.byKey(const ValueKey('messageFilter_addRuleButton'))); + await tester.pumpAndSettle(); + await tester.enterText(find.byType(TextField), 'spam'); + await tester.tap(find.text('Cancel')); + await tester.pumpAndSettle(); + expect(service.rules, isEmpty); + }); + + testWidgets('reset learning asks first and clears examples', (tester) async { + await service.markSpam(sender: 'Bot', text: 'Buy cheap radios now'); + await service.markNotSpam( + channelId: 'c', + sender: 'Ann', + text: 'See you at the meetup', + ); + await pumpScreen(tester); + expect(find.text('1 spam and 1 not-spam examples'), findsOneWidget); + + await tester.tap(find.byKey(const ValueKey('messageFilter_resetLearning'))); + await tester.pumpAndSettle(); + await tester.tap(find.text('Cancel')); + await tester.pumpAndSettle(); + expect(service.spamExampleCount, 1); + + await tester.tap(find.byKey(const ValueKey('messageFilter_resetLearning'))); + await tester.pumpAndSettle(); + await tester.tap(find.widgetWithText(FilledButton, 'Reset learning')); + await tester.pumpAndSettle(); + expect(service.spamExampleCount, 0); + expect(service.notSpamExampleCount, 0); + expect(find.text('0 spam and 0 not-spam examples'), findsOneWidget); + }); + + testWidgets('filtered messages tile opens the empty list', (tester) async { + await pumpScreen(tester); + await tester.tap(find.text('Filtered messages (0)')); + await tester.pumpAndSettle(); + expect(find.byType(FilteredMessagesScreen), findsOneWidget); + expect(find.text('Nothing has been filtered.'), findsOneWidget); + }); + + testWidgets('dialog prefills a new rule from a message', (tester) async { + FilterRule? result; + await tester.pumpWidget( + MaterialApp( + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + home: Builder( + builder: (context) => Scaffold( + body: TextButton( + onPressed: () async { + result = await showFilterRuleDialog( + context, + initialPattern: ' Bot ', + initialField: FilterRuleField.sender, + ); + }, + child: const Text('open'), + ), + ), + ), + ), + ); + await tester.tap(find.text('open')); + await tester.pumpAndSettle(); + expect(find.text('Bot'), findsOneWidget); + await tester.tap(find.widgetWithText(FilledButton, 'Save')); + await tester.pumpAndSettle(); + expect(result?.pattern, 'Bot'); + expect(result?.field, FilterRuleField.sender); + expect(result?.match, FilterRuleMatch.contains); + expect(result?.id, isNotEmpty); + }); +} diff --git a/test/services/message_filter/duplicate_tracker_test.dart b/test/services/message_filter/duplicate_tracker_test.dart new file mode 100644 index 00000000..9619a412 --- /dev/null +++ b/test/services/message_filter/duplicate_tracker_test.dart @@ -0,0 +1,283 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/models/message_filter.dart'; +import 'package:meshcore_open/services/message_filter/duplicate_tracker.dart'; + +void main() { + final t0 = DateTime(2026, 1, 1, 12); + + test('same sender repeat within 10 minutes is a duplicate', () { + final tracker = DuplicateTracker(); + expect( + tracker.check(channelId: 'c', sender: 'Bob', text: 'Hello', at: t0), + isNull, + ); + expect( + tracker.check( + channelId: 'c', + sender: 'Bob', + text: 'hello!', + at: t0.add(const Duration(minutes: 9)), + ), + FilterReason.duplicate, + ); + }); + + test('same sender repeat after the window is not a duplicate', () { + final tracker = DuplicateTracker(); + tracker.check(channelId: 'c', sender: 'Bob', text: 'Hello', at: t0); + expect( + tracker.check( + channelId: 'c', + sender: 'Bob', + text: 'Hello', + at: t0.add(const Duration(minutes: 11)), + ), + isNull, + ); + }); + + test('channels are tracked separately', () { + final tracker = DuplicateTracker(); + tracker.check(channelId: 'a', sender: 'Bob', text: 'Hello', at: t0); + expect( + tracker.check(channelId: 'b', sender: 'Bob', text: 'Hello', at: t0), + isNull, + ); + }); + + test('short greetings from many senders are never cross-sender', () { + final tracker = DuplicateTracker(); + // New Year's Eve: everyone sends the same few words at once. + const greetings = [ + 'Happy New Year!', + 'happy new year', + 'HAPPY NEW YEAR!!', + 'Happy new year 🎉', + 'Happy New Year everyone!', + ]; + for (var i = 0; i < 8; i++) { + expect( + tracker.check( + channelId: 'c', + sender: 'person$i', + text: greetings[i % greetings.length], + at: t0.add(Duration(minutes: i)), + ), + isNull, + reason: 'greeting from person$i must stay visible', + ); + } + // Five words is still a greeting, not a campaign. + for (var i = 0; i < 4; i++) { + expect( + tracker.check( + channelId: 'c', + sender: 'friend$i', + text: 'Merry Christmas to you all', + at: t0.add(Duration(minutes: 10 + i)), + ), + isNull, + ); + } + }); + + test('third distinct sender of the same long text is cross-sender', () { + final tracker = DuplicateTracker(); + const text = 'Join the best mesh client now, it is free'; + expect( + tracker.check(channelId: 'c', sender: 'A', text: text, at: t0), + isNull, + ); + expect( + tracker.check( + channelId: 'c', + sender: 'B', + text: text, + at: t0.add(const Duration(minutes: 5)), + ), + isNull, + ); + expect( + tracker.check( + channelId: 'c', + sender: 'C', + text: text, + at: t0.add(const Duration(minutes: 20)), + ), + FilterReason.crossSenderDuplicate, + ); + }); + + test('short texts never count as cross-sender duplicates', () { + final tracker = DuplicateTracker(); + for (final sender in ['A', 'B', 'C', 'D']) { + expect( + tracker.check(channelId: 'c', sender: sender, text: 'hi all', at: t0), + isNull, + ); + } + }); + + test('cross-sender window is 30 minutes', () { + final tracker = DuplicateTracker(); + const text = 'Join the best mesh now'; + tracker.check(channelId: 'c', sender: 'A', text: text, at: t0); + tracker.check( + channelId: 'c', + sender: 'B', + text: text, + at: t0.add(const Duration(minutes: 1)), + ); + expect( + tracker.check( + channelId: 'c', + sender: 'C', + text: text, + at: t0.add(const Duration(minutes: 31)), + ), + isNull, + ); + }); + + test('filtered texts are still recorded so floods keep being caught', () { + final tracker = DuplicateTracker(); + tracker.check(channelId: 'c', sender: 'Bob', text: 'buy now', at: t0); + for (var i = 1; i <= 5; i++) { + expect( + tracker.check( + channelId: 'c', + sender: 'Bob', + text: 'buy now', + at: t0.add(Duration(minutes: 8 * i)), + ), + FilterReason.duplicate, + ); + } + }); + + test('allow exempts the text in that channel', () { + final tracker = DuplicateTracker(); + tracker.check(channelId: 'c', sender: 'Bob', text: 'Hello', at: t0); + tracker.allow('c', 'HELLO!'); + expect(tracker.isAllowed('c', 'hello'), isTrue); + expect(tracker.isAllowed('other', 'hello'), isFalse); + expect( + tracker.check(channelId: 'c', sender: 'Bob', text: 'Hello', at: t0), + isNull, + ); + tracker.clear(); + expect(tracker.isAllowed('c', 'hello'), isFalse); + }); + + test('empty normalized text is ignored', () { + final tracker = DuplicateTracker(); + tracker.check(channelId: 'c', sender: 'Bob', text: '👍', at: t0); + expect( + tracker.check(channelId: 'c', sender: 'Bob', text: '👍', at: t0), + isNull, + ); + }); + + group('send-time windows', () { + test('history synced in a burst is not a duplicate', () { + final tracker = DuplicateTracker(); + // Sent three hours apart, delivered seconds apart after reconnecting. + expect( + tracker.check( + channelId: 'c', + sender: 'Bob', + text: 'Heading out now', + at: t0, + receivedAt: t0.add(const Duration(hours: 5)), + ), + isNull, + ); + expect( + tracker.check( + channelId: 'c', + sender: 'Bob', + text: 'Heading out now', + at: t0.add(const Duration(hours: 3)), + receivedAt: t0.add(const Duration(hours: 5, seconds: 2)), + ), + isNull, + ); + }); + + test('out-of-order delivery is still caught', () { + final tracker = DuplicateTracker(); + // The newer copy arrives first. + expect( + tracker.check( + channelId: 'c', + sender: 'Bob', + text: 'Buy cheap nodes', + at: t0.add(const Duration(minutes: 5)), + receivedAt: t0.add(const Duration(minutes: 30)), + ), + isNull, + ); + expect( + tracker.check( + channelId: 'c', + sender: 'Bob', + text: 'Buy cheap nodes', + at: t0, + receivedAt: t0.add(const Duration(minutes: 30, seconds: 1)), + ), + FilterReason.duplicate, + ); + + const campaign = 'the meshcore trademark grab is theft, boycott him'; + final now = t0.add(const Duration(hours: 1)); + for (final (i, sender) in ['x', 'y'].indexed) { + expect( + tracker.check( + channelId: 'c', + sender: sender, + text: campaign, + at: t0.add(Duration(minutes: 20 - i * 10)), + receivedAt: now, + ), + isNull, + ); + } + expect( + tracker.check( + channelId: 'c', + sender: 'z', + text: campaign, + at: t0, + receivedAt: now, + ), + FilterReason.crossSenderDuplicate, + ); + }); + + test('a sender clock years ahead does not evict other entries', () { + final tracker = DuplicateTracker(); + tracker.check( + channelId: 'c', + sender: 'Bob', + text: 'Morning all, testing my node', + at: t0, + ); + tracker.check( + channelId: 'c', + sender: 'Wonky', + text: 'Clock is way off', + at: t0.add(const Duration(days: 900)), + receivedAt: t0.add(const Duration(minutes: 1)), + ); + expect( + tracker.check( + channelId: 'c', + sender: 'Bob', + text: 'Morning all, testing my node', + at: t0.add(const Duration(minutes: 2)), + ), + FilterReason.duplicate, + ); + }); + }); +} diff --git a/test/services/message_filter/message_filter_service_test.dart b/test/services/message_filter/message_filter_service_test.dart new file mode 100644 index 00000000..30ea3a50 --- /dev/null +++ b/test/services/message_filter/message_filter_service_test.dart @@ -0,0 +1,307 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/models/message_filter.dart'; +import 'package:meshcore_open/services/message_filter/message_filter_service.dart'; +import 'package:meshcore_open/storage/message_filter_store.dart'; +import 'package:meshcore_open/storage/prefs_manager.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +const _channel = 'chan1'; + +const _chat = [ + 'Good morning everyone', + 'Anyone hearing the repeater on the hill today?', + 'I just got back from the hike, signal was great', + 'Testing from the north side of town', + 'Thanks for the advert, I can see you now', + 'How many hops is your path to the city?', + 'Weather looks rough tonight, stay safe', + 'My battery is at 40 percent after two days', + 'Who is running the new solar node?', + 'Copy that, heard you loud and clear', + 'Is the meetup still on for Saturday?', + 'Yes, 10am at the library parking lot', + 'I moved my antenna higher, let me know if it helps', + 'Reception improved a lot, thanks', + 'Lunch break, back in an hour', + 'Does anyone have a spare LoRa board to lend?', + 'Ping from the coffee shop downtown', + 'See you all tomorrow', + 'Happy birthday Carol!', + 'Can someone check if my messages are getting through?', +]; + +void main() { + late DateTime now; + late MessageFilterService service; + + Future create() async { + final s = MessageFilterService( + store: MessageFilterStore(), + clock: () => now, + ); + await s.load(); + return s; + } + + setUp(() async { + SharedPreferences.setMockInitialValues({}); + PrefsManager.reset(); + await PrefsManager.initialize(); + now = DateTime(2026, 1, 1, 12); + service = await create(); + }); + + FilterVerdict? eval( + String sender, + String text, { + String channel = _channel, + }) => service.evaluate(channelId: channel, sender: sender, text: text); + + test('defaults: enabled, nothing filtered for normal chat', () { + expect(service.settings.enabled, isTrue); + expect(service.settings.displayMode, FilterDisplayMode.placeholder); + expect(service.isChannelFiltered(_channel), isTrue); + expect(eval('Bob', 'hello there'), isNull); + }); + + test('skips outgoing, reactions, payloads, disabled and excluded', () async { + await service.addRule( + FilterRule(id: MessageFilterService.newRuleId(), pattern: 'bad'), + ); + expect( + service.evaluate( + channelId: _channel, + sender: 'me', + text: 'bad', + isOutgoing: true, + ), + isNull, + ); + expect( + service.evaluate( + channelId: _channel, + sender: 'a', + text: 'bad', + isReaction: true, + ), + isNull, + ); + expect(eval('a', 'g:bad-gif'), isNull); + expect(eval('a', 'm:bad'), isNull); + + await service.setChannelExcluded(_channel, true); + expect(service.isChannelFiltered(_channel), isFalse); + expect(eval('a', 'bad'), isNull); + expect(eval('a', 'bad', channel: 'other')?.reason, FilterReason.textRule); + + await service.setChannelExcluded(_channel, false); + await service.updateSettings(service.settings.copyWith(enabled: false)); + expect(eval('a', 'bad'), isNull); + }); + + test( + 'sender rules win over text rules; disabled rules are ignored', + () async { + await service.addRule( + const FilterRule( + id: 't', + pattern: 'promo', + field: FilterRuleField.text, + ), + ); + await service.addRule( + const FilterRule( + id: 's', + pattern: 'Spammer', + field: FilterRuleField.sender, + match: FilterRuleMatch.exact, + ), + ); + expect( + eval('spammer', 'promo time'), + const FilterVerdict(reason: FilterReason.senderRule, detail: 'Spammer'), + ); + expect( + eval('Bob', 'big PROMO'), + const FilterVerdict(reason: FilterReason.textRule, detail: 'promo'), + ); + await service.updateRule( + const FilterRule(id: 't', pattern: 'promo', enabled: false), + ); + expect(eval('Bob', 'another promo'), isNull); + await service.removeRule('s'); + expect(service.rules.map((r) => r.id), ['t']); + }, + ); + + test('repeated characters, togglable', () async { + expect(eval('a', 'nooooooooo')?.reason, FilterReason.repeatedCharacters); + await service.updateSettings( + service.settings.copyWith(repeatedCharacters: false), + ); + expect(eval('b', 'yesssssssss'), isNull); + }); + + test('duplicates: same sender and cross sender', () { + expect(eval('a', 'meet at the park'), isNull); + now = now.add(const Duration(minutes: 2)); + expect( + eval('a', 'Meet at the park!'), + const FilterVerdict(reason: FilterReason.duplicate), + ); + const campaign = 'the meshcore trademark grab is theft, boycott him'; + expect(eval('b', campaign), isNull); + expect(eval('d', campaign), isNull); + expect(eval('c', campaign)?.reason, FilterReason.crossSenderDuplicate); + // Short greetings from several senders are left alone. + expect(eval('e', 'Happy New Year!'), isNull); + expect(eval('f', 'Happy New Year!'), isNull); + expect(eval('g', 'Happy New Year!'), isNull); + }); + + test('duplicates setting off still records but does not filter', () async { + await service.updateSettings(service.settings.copyWith(duplicates: false)); + expect(eval('a', 'meet at the park'), isNull); + expect(eval('a', 'meet at the park'), isNull); + await service.updateSettings(service.settings.copyWith(duplicates: true)); + expect(eval('a', 'meet at the park')?.reason, FilterReason.duplicate); + }); + + test('rule-filtered texts are still recorded for duplicates', () async { + await service.addRule(const FilterRule(id: 'x', pattern: 'buy')); + expect(eval('a', 'buy stuff')?.reason, FilterReason.textRule); + await service.removeRule('x'); + expect(eval('a', 'buy stuff')?.reason, FilterReason.duplicate); + }); + + test('not spam exempts duplicates in that channel', () async { + eval('a', 'meet at the park'); + await service.markNotSpam( + channelId: _channel, + sender: 'a', + text: 'meet at the park', + ); + expect(eval('a', 'meet at the park'), isNull); + expect(service.notSpamExampleCount, 1); + }); + + test('learning needs two spam taps, then catches similar promos', () async { + for (var i = 0; i < _chat.length; i++) { + service.recordClean(sender: 'User$i', text: _chat[i]); + } + await service.markSpam( + sender: 'PromoBot', + text: 'Download MeshOS now! Free firmware at meshos.example', + ); + expect(service.spamExampleCount, 1); + expect( + eval('X', 'Free MeshOS firmware download at meshos.example'), + isNull, + ); + + await service.markSpam( + sender: 'Deals', + text: 'Free MeshOS firmware upgrade, download at meshos.example now', + ); + expect(service.spamExampleCount, 2); + expect( + eval('Y', 'Get free MeshOS firmware download now meshos.example')?.reason, + FilterReason.learned, + ); + expect(eval('Z', 'Anyone on the hill repeater tonight?'), isNull); + + await service.updateSettings(service.settings.copyWith(learning: false)); + expect( + eval('W', 'Get the MeshOS firmware download free meshos.example'), + isNull, + ); + }); + + test('marking spam twice for the same text keeps one example', () async { + await service.markSpam(sender: 'a', text: 'Buy now'); + await service.markSpam(sender: 'a', text: 'buy NOW'); + expect(service.spamExampleCount, 1); + await service.markNotSpam( + channelId: _channel, + sender: 'a', + text: 'buy now', + ); + expect(service.spamExampleCount, 0); + expect(service.notSpamExampleCount, 1); + }); + + test('state persists across instances and reset keeps rules', () async { + await service.addRule(const FilterRule(id: 'r1', pattern: 'promo')); + await service.updateSettings( + service.settings.copyWith(displayMode: FilterDisplayMode.hide), + ); + await service.markSpam(sender: 'a', text: 'spam one'); + await service.markNotSpam(channelId: _channel, sender: 'b', text: 'hi'); + + final reloaded = await create(); + expect(reloaded.rules.single.pattern, 'promo'); + expect(reloaded.settings.displayMode, FilterDisplayMode.hide); + expect(reloaded.spamExampleCount, 1); + expect(reloaded.notSpamExampleCount, 1); + + await reloaded.resetLearning(); + expect(reloaded.spamExampleCount, 0); + expect(reloaded.notSpamExampleCount, 0); + expect(reloaded.rules, hasLength(1)); + final again = await create(); + expect(again.spamExampleCount, 0); + expect(again.rules, hasLength(1)); + }); + + test('notifies listeners on changes', () async { + var count = 0; + service.addListener(() => count++); + await service.addRule(const FilterRule(id: 'n', pattern: 'x')); + await service.markSpam(sender: 'a', text: 'b'); + await service.setChannelExcluded('c', true); + expect(count, 3); + }); + + test('addRule with index restores a deleted rule in place', () async { + for (final id in ['a', 'b', 'c']) { + await service.addRule(FilterRule(id: id, pattern: id)); + } + final b = service.rules[1]; + await service.removeRule('b'); + await service.addRule(b, index: 1); + expect(service.rules.map((r) => r.id), ['a', 'b', 'c']); + await service.addRule(const FilterRule(id: 'z', pattern: 'z'), index: 99); + expect(service.rules.last.id, 'z'); + }); + + test('newRuleId is unique', () { + final ids = List.generate(100, (_) => MessageFilterService.newRuleId()); + expect(ids.toSet(), hasLength(100)); + }); + + test( + 'learning activates once clean examples arrive after spam taps', + () async { + // The first two messages received are the ones marked spam, so training + // has no clean examples yet and the classifier stays inactive. + await service.markSpam( + sender: 'PromoBot', + text: 'Download MeshOS now! Free firmware at meshos.example', + ); + await service.markSpam( + sender: 'Deals', + text: 'Free MeshOS firmware upgrade, download at meshos.example now', + ); + const probe = 'Get free MeshOS firmware download now meshos.example'; + expect(eval('A', probe), isNull); + + // Ordinary chat then arrives; no further taps. + for (var i = 0; i < _chat.length; i++) { + service.recordClean(sender: 'User$i', text: _chat[i]); + } + await Future.delayed(Duration.zero); // let the queued retrain run + expect(eval('B', probe)?.reason, FilterReason.learned); + expect(eval('C', 'Anyone on the hill repeater tonight?'), isNull); + }, + ); +} diff --git a/test/services/message_filter/message_filter_text_test.dart b/test/services/message_filter/message_filter_text_test.dart new file mode 100644 index 00000000..74a4183e --- /dev/null +++ b/test/services/message_filter/message_filter_text_test.dart @@ -0,0 +1,155 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/models/message_filter.dart'; +import 'package:meshcore_open/services/message_filter/message_filter_text.dart'; + +FilterRule _rule( + String pattern, { + FilterRuleField field = FilterRuleField.text, + FilterRuleMatch match = FilterRuleMatch.contains, +}) => FilterRule(id: 'r', pattern: pattern, field: field, match: match); + +void main() { + group('normalize', () { + test('lower-cases, collapses whitespace and trims', () { + expect( + MessageFilterText.normalize(' Hello \n\t WORLD '), + 'hello world', + ); + }); + + test('strips accents', () { + expect(MessageFilterText.normalize('Ça vá Ñoño Öl'), 'ca va nono ol'); + // Decomposed form (combining marks). + expect(MessageFilterText.normalize('Café'), 'cafe'); + }); + + test('maps Cyrillic and Greek look-alikes to Latin', () { + // Cyrillic М е о and Greek Ο. + expect(MessageFilterText.normalize('Мeshоs'), 'meshos'); + expect(MessageFilterText.normalize('MeshΟS'), 'meshos'); + }); + + test('removes zero-width and soft hyphen characters', () { + expect(MessageFilterText.normalize('me​sh‌‍o⁠s­'), 'meshos'); + }); + + test('folds fullwidth and styled letters', () { + expect(MessageFilterText.normalize('MESH'), 'mesh'); + expect(MessageFilterText.normalize('\u{1D400}\u{1D41B}'), 'ab'); + }); + }); + + group('normalizeForDuplicates', () { + test('drops mentions, punctuation and emoji', () { + expect( + MessageFilterText.normalizeForDuplicates('@[Bob] Hello, world!!! 😀'), + 'hello world', + ); + expect( + MessageFilterText.normalizeForDuplicates('Hello world'), + MessageFilterText.normalizeForDuplicates('hello... WORLD?'), + ); + }); + }); + + group('matchesRule', () { + test('contains', () { + final rule = _rule('MeshOS'); + expect( + MessageFilterText.matchesRule(rule, sender: 'a', text: 'try meshos!'), + isTrue, + ); + expect( + MessageFilterText.matchesRule(rule, sender: 'a', text: 'mesh os'), + isFalse, + ); + }); + + test('whole word uses unicode boundaries', () { + final rule = _rule('cat', match: FilterRuleMatch.wholeWord); + expect( + MessageFilterText.matchesRule(rule, sender: 'a', text: 'my cat!'), + isTrue, + ); + expect( + MessageFilterText.matchesRule(rule, sender: 'a', text: 'Cat'), + isTrue, + ); + expect( + MessageFilterText.matchesRule(rule, sender: 'a', text: 'category'), + isFalse, + ); + expect( + MessageFilterText.matchesRule(rule, sender: 'a', text: 'catß'), + isFalse, + ); + final phrase = _rule('free (offer)', match: FilterRuleMatch.wholeWord); + expect( + MessageFilterText.matchesRule( + phrase, + sender: 'a', + text: 'a FREE (offer) now', + ), + isTrue, + ); + }); + + test('exact', () { + final rule = _rule('hello', match: FilterRuleMatch.exact); + expect( + MessageFilterText.matchesRule(rule, sender: 'a', text: ' HELLO '), + isTrue, + ); + expect( + MessageFilterText.matchesRule(rule, sender: 'a', text: 'hello there'), + isFalse, + ); + }); + + test('respects the field', () { + final sender = _rule('spammer', field: FilterRuleField.sender); + expect( + MessageFilterText.matchesRule(sender, sender: 'Spammer', text: 'hi'), + isTrue, + ); + expect( + MessageFilterText.matchesRule(sender, sender: 'bob', text: 'spammer'), + isFalse, + ); + final both = _rule('spammer', field: FilterRuleField.both); + expect( + MessageFilterText.matchesRule(both, sender: 'bob', text: 'spammer'), + isTrue, + ); + expect( + MessageFilterText.matchesRule(both, sender: 'SPAMMER', text: 'hi'), + isTrue, + ); + }); + + test('empty pattern never matches', () { + expect( + MessageFilterText.matchesRule(_rule(' '), sender: 'a', text: 'b'), + isFalse, + ); + }); + }); + + test('repeated characters', () { + expect(MessageFilterText.hasRepeatedCharacters('aaaaaaaa'), isTrue); + expect(MessageFilterText.hasRepeatedCharacters('wow!!!!!!!!'), isTrue); + expect(MessageFilterText.hasRepeatedCharacters('AAAAaaaa'), isTrue); + expect(MessageFilterText.hasRepeatedCharacters('😀' * 8), isTrue); + expect(MessageFilterText.hasRepeatedCharacters('aaaaaaa'), isFalse); + expect( + MessageFilterText.hasRepeatedCharacters('hello there'), + isFalse, + ); + }); + + test('structured payloads', () { + expect(MessageFilterText.isStructuredPayload('g:abc'), isTrue); + expect(MessageFilterText.isStructuredPayload(' m:xyz'), isTrue); + expect(MessageFilterText.isStructuredPayload('good morning'), isFalse); + }); +} diff --git a/test/services/message_filter/ngram_spam_classifier_test.dart b/test/services/message_filter/ngram_spam_classifier_test.dart new file mode 100644 index 00000000..af1675e6 --- /dev/null +++ b/test/services/message_filter/ngram_spam_classifier_test.dart @@ -0,0 +1,149 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/models/message_filter.dart'; +import 'package:meshcore_open/services/message_filter/ngram_spam_classifier.dart'; + +FilterExample _ex(String sender, String text) => + FilterExample(sender: sender, text: text, addedAtMs: 0); + +final _spam = [ + _ex( + 'PromoBot', + 'Download MeshOS now! Free firmware upgrade at meshos.example', + ), + _ex( + 'MeshDeals', + 'FREE upgrade!!! Get MeshOS firmware today, visit meshos.example', + ), + _ex( + 'PromoBot', + 'Best firmware ever: MeshOS. Download free at meshos.example now', + ), + _ex('Promo2', 'Limited offer: MeshOS firmware download free, meshos.example'), + _ex( + 'MeshDeals', + 'Upgrade your node with MeshOS! Free download at meshos.example', + ), + _ex('Promo3', 'Get the free MeshOS firmware now - meshos.example download'), +]; + +final _ham = [ + _ex('Alice', 'Good morning everyone'), + _ex('Bob', 'Anyone hearing the repeater on the hill today?'), + _ex('Carol', 'I just got back from the hike, signal was great'), + _ex('Dave', 'Testing from the north side of town'), + _ex('Alice', 'Thanks for the advert, I can see you now'), + _ex('Eve', 'How many hops is your path to the city?'), + _ex('Bob', 'Weather looks rough tonight, stay safe'), + _ex('Frank', 'My battery is at 40 percent after two days'), + _ex('Carol', 'Who is running the new solar node?'), + _ex('Dave', 'Copy that, heard you loud and clear'), + _ex('Grace', 'Is the meetup still on for Saturday?'), + _ex('Heidi', 'Yes, 10am at the library parking lot'), + _ex('Ivan', 'I moved my antenna higher, let me know if it helps'), + _ex('Judy', 'Reception improved a lot, thanks'), + _ex('Alice', 'Lunch break, back in an hour'), + _ex('Bob', 'Does anyone have a spare LoRa board to lend?'), + _ex('Frank', 'Ping from the coffee shop downtown'), + _ex('Grace', 'See you all tomorrow'), + _ex('Eve', 'The traffic on the highway is terrible right now'), + _ex('Heidi', 'Happy birthday Carol!'), + _ex('Ivan', 'Can someone check if my messages are getting through?'), + _ex('Judy', 'Got it, three hops via the hill repeater'), + _ex('Carol', 'Thank you all, great community here'), + _ex('Dave', 'Power is out in my area, running on battery'), + _ex('Alice', 'Nice sunset from the ridge'), + _ex('Bob', 'Updating my node settings, brb'), + _ex('Eve', 'Good night folks'), + _ex('Frank', 'Anyone near the river trail?'), + _ex('Grace', 'The new channel works well for our group'), + _ex('Heidi', 'Is there a map of the repeaters somewhere?'), +]; + +void main() { + test('untrained classifier returns 0', () { + final classifier = NgramSpamClassifier(); + expect(classifier.isTrained, isFalse); + expect(classifier.probability('x', 'anything'), 0.0); + }); + + test('needs both classes to train', () { + final classifier = NgramSpamClassifier()..train(_spam, const []); + expect(classifier.isTrained, isFalse); + }); + + test('FNV-1a 32 matches reference vectors', () { + expect(NgramSpamClassifier.fnv1a32(''), 0x811C9DC5); + expect(NgramSpamClassifier.fnv1a32('a'), 0xE40C292C); + expect(NgramSpamClassifier.fnv1a32('foobar'), 0xBF9CF968); + }); + + test('feature strings include char n-grams, words, bigrams, sender', () { + final features = NgramSpamClassifier.featureStrings('Bob', 'Hi there'); + expect(features, contains('c: hi ')); + expect(features, contains('c: th')); + expect(features, contains('c:there')); + expect(features, contains('w:there')); + expect(features, contains('b:hi there')); + expect(features, contains('s:bob')); + }); + + test('scores held-out promo high and ordinary chat low', () { + final classifier = NgramSpamClassifier()..train(_spam, _ham); + expect(classifier.isTrained, isTrue); + + final promo = classifier.probability( + 'NewPromo', + 'Free MeshOS firmware download now at meshos.example!', + ); + expect(promo, greaterThanOrEqualTo(0.8)); + + for (final text in [ + 'Anyone on the hill repeater tonight?', + 'Good morning, heading out for a hike', + 'My node battery lasted three days', + 'See you at the meetup on Saturday', + ]) { + expect(classifier.probability('Zoe', text), lessThan(0.5), reason: text); + } + }); + + test('look-alike characters do not dodge the classifier', () { + final classifier = NgramSpamClassifier()..train(_spam, _ham); + // Cyrillic "е"/"о" and a zero-width space. + final p = classifier.probability( + 'NewPromo', + 'Frеe MeshОS firm​ware download now at meshos.example', + ); + expect(p, greaterThanOrEqualTo(0.8)); + }); + + test('training is deterministic', () { + final a = NgramSpamClassifier()..train(_spam, _ham); + final b = NgramSpamClassifier()..train(_spam, _ham); + const text = 'free firmware download'; + expect(a.probability('x', text), b.probability('x', text)); + }); + + test('trains 500 documents quickly', () { + final spam = []; + final ham = []; + for (var i = 0; i < 200; i++) { + final s = _spam[i % _spam.length]; + spam.add(_ex('${s.sender}$i', '${s.text} code $i')); + } + for (var i = 0; i < 300; i++) { + final h = _ham[i % _ham.length]; + ham.add(_ex('${h.sender}$i', '${h.text} number $i')); + } + final classifier = NgramSpamClassifier(); + // Warm up the JIT once, then measure. + classifier.train(spam.take(20).toList(), ham.take(20).toList()); + final stopwatch = Stopwatch()..start(); + classifier.train(spam, ham); + stopwatch.stop(); + expect(classifier.isTrained, isTrue); + expect(stopwatch.elapsedMilliseconds, lessThan(500)); + // ignore: avoid_print + print('Trained 500 docs in ${stopwatch.elapsedMilliseconds} ms'); + }); +} diff --git a/test/storage/message_filter_store_test.dart b/test/storage/message_filter_store_test.dart new file mode 100644 index 00000000..35976377 --- /dev/null +++ b/test/storage/message_filter_store_test.dart @@ -0,0 +1,104 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/models/message_filter.dart'; +import 'package:meshcore_open/storage/message_filter_store.dart'; +import 'package:meshcore_open/storage/prefs_manager.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +Future _init(Map values) async { + SharedPreferences.setMockInitialValues(values); + PrefsManager.reset(); + await PrefsManager.initialize(); +} + +void main() { + test('empty prefs load defaults', () async { + await _init({}); + final store = MessageFilterStore(); + final settings = store.loadSettings(); + expect(settings.enabled, isTrue); + expect(settings.displayMode, FilterDisplayMode.placeholder); + expect(settings.duplicates, isTrue); + expect(settings.repeatedCharacters, isTrue); + expect(settings.learning, isTrue); + expect(settings.excludedChannelIds, isEmpty); + expect(store.loadRules(), isEmpty); + expect(store.loadSpamExamples(), isEmpty); + expect(store.loadHamExamples(), isEmpty); + expect(store.loadRecentClean(), isEmpty); + }); + + test('round-trips settings, rules and examples', () async { + await _init({}); + final store = MessageFilterStore(); + await store.saveSettings( + const MessageFilterSettings( + enabled: false, + displayMode: FilterDisplayMode.hide, + duplicates: false, + repeatedCharacters: false, + learning: false, + excludedChannelIds: {'a', 'slot:3'}, + ), + ); + await store.saveRules(const [ + FilterRule( + id: '1', + pattern: 'MeshOS', + field: FilterRuleField.both, + match: FilterRuleMatch.wholeWord, + enabled: false, + ), + ]); + const example = FilterExample(sender: 's', text: 't', addedAtMs: 42); + await store.saveSpamExamples(const [example]); + await store.saveHamExamples(const [example, example]); + await store.saveRecentClean(const [example]); + + final settings = store.loadSettings(); + expect(settings.enabled, isFalse); + expect(settings.displayMode, FilterDisplayMode.hide); + expect(settings.duplicates, isFalse); + expect(settings.repeatedCharacters, isFalse); + expect(settings.learning, isFalse); + expect(settings.excludedChannelIds, {'a', 'slot:3'}); + expect(store.loadRules(), const [ + FilterRule( + id: '1', + pattern: 'MeshOS', + field: FilterRuleField.both, + match: FilterRuleMatch.wholeWord, + enabled: false, + ), + ]); + final spam = store.loadSpamExamples().single; + expect((spam.sender, spam.text, spam.addedAtMs), ('s', 't', 42)); + expect(store.loadHamExamples(), hasLength(2)); + expect(store.loadRecentClean(), hasLength(1)); + }); + + test('tolerates malformed data', () async { + await _init({ + MessageFilterStore.settingsKey: '{not json', + MessageFilterStore.rulesKey: + '[{"id":"1","pattern":"ok","field":"weird","match":"nope"}, 5, ' + '{"id":"","pattern":"x"}]', + MessageFilterStore.spamExamplesKey: '{"a":1}', + }); + final store = MessageFilterStore(); + expect(store.loadSettings().enabled, isTrue); + final rule = store.loadRules().single; + expect(rule.pattern, 'ok'); + expect(rule.field, FilterRuleField.text); + expect(rule.match, FilterRuleMatch.contains); + expect(rule.enabled, isTrue); + expect(store.loadSpamExamples(), isEmpty); + }); + + test('filter reason json helpers', () { + for (final reason in FilterReason.values) { + expect(filterReasonFromJson(filterReasonToJson(reason)), reason); + } + expect(filterReasonFromJson(null), isNull); + expect(filterReasonFromJson('unknown'), isNull); + }); +} diff --git a/test/widgets/filtered_message_ghost_test.dart b/test/widgets/filtered_message_ghost_test.dart new file mode 100644 index 00000000..76fd7783 --- /dev/null +++ b/test/widgets/filtered_message_ghost_test.dart @@ -0,0 +1,265 @@ +import 'package:flutter/material.dart'; +import 'package:flutter/semantics.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/l10n/app_localizations.dart'; +import 'package:meshcore_open/l10n/app_localizations_en.dart'; +import 'package:meshcore_open/models/message_filter.dart'; +import 'package:meshcore_open/widgets/filtered_message_ghost.dart'; + +Future _pump(WidgetTester tester, Widget child) { + return tester.pumpWidget( + MaterialApp( + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + home: Scaffold(body: ListView(children: [child])), + ), + ); +} + +void main() { + group('FilteredMessageGhost', () { + testWidgets('single message: copy, reason, tap target', (tester) async { + var taps = 0; + await _pump( + tester, + FilteredMessageGhost( + count: 1, + reason: 'Filtered: repeated message', + onTap: () => taps++, + ), + ); + + expect(find.text('Hidden message · Tap to view'), findsOneWidget); + expect(find.text('Filtered: repeated message'), findsOneWidget); + expect(find.byIcon(Icons.visibility_off_outlined), findsOneWidget); + expect(find.byTooltip('Hidden by your message filter'), findsOneWidget); + + final inkWell = find.byType(InkWell); + expect(tester.getSize(inkWell).height, greaterThanOrEqualTo(48)); + + await tester.tap(find.byType(FilteredMessageGhost)); + expect(taps, 1); + }); + + testWidgets('expanded header offers one-tap collapse', (tester) async { + var taps = 0; + await _pump( + tester, + FilteredMessageGhost( + count: 4, + reason: 'Filtered: repeated message', + expanded: true, + onTap: () => taps++, + ), + ); + + expect( + find.text('Showing 4 hidden messages · Tap to hide'), + findsOneWidget, + ); + expect(find.byIcon(Icons.expand_less), findsOneWidget); + expect(find.byIcon(Icons.visibility_off_outlined), findsNothing); + + await tester.tap(find.byType(FilteredMessageGhost)); + expect(taps, 1); + + await _pump( + tester, + FilteredMessageGhost( + count: 1, + reason: 'Filtered: repeated message', + expanded: true, + onTap: () {}, + ), + ); + expect(find.text('Showing hidden message · Tap to hide'), findsOneWidget); + }); + + testWidgets('run: plural copy and semantics label', (tester) async { + final handle = tester.ensureSemantics(); + await _pump( + tester, + FilteredMessageGhost( + count: 3, + reason: 'Filtered: repeated characters', + onTap: () {}, + ), + ); + + expect(find.text('3 hidden messages · Tap to view'), findsOneWidget); + expect( + find.bySemanticsLabel( + '3 hidden messages · Tap to view. Filtered: repeated characters', + ), + findsOneWidget, + ); + expect( + tester.getSemantics(find.byType(FilteredMessageGhost)), + matchesSemantics( + isButton: true, + hasTapAction: true, + label: + '3 hidden messages · Tap to view. Filtered: repeated characters', + ), + ); + handle.dispose(); + }); + + testWidgets('screen-reader tap reveals the run', (tester) async { + final handle = tester.ensureSemantics(); + var taps = 0; + await _pump( + tester, + FilteredMessageGhost(count: 2, reason: 'r', onTap: () => taps++), + ); + final node = tester.getSemantics(find.byType(FilteredMessageGhost)); + node.owner!.performAction(node.id, SemanticsAction.tap); + expect(taps, 1); + handle.dispose(); + }); + + testWidgets('grows with the chat text scale', (tester) async { + await _pump( + tester, + FilteredMessageGhost(count: 1, reason: 'r', onTap: () {}), + ); + final small = tester.getSize(find.byType(InkWell)).height; + await _pump( + tester, + FilteredMessageGhost(count: 1, reason: 'r', textScale: 2, onTap: () {}), + ); + final large = tester.getSize(find.byType(InkWell)).height; + expect(large, greaterThan(small)); + }); + }); + + group('FilteredMessageBanner', () { + testWidgets('shows the reason and both actions', (tester) async { + var notSpam = 0; + var hide = 0; + await _pump( + tester, + FilteredMessageBanner( + reason: 'Filtered: you marked this as spam', + color: Colors.black, + onNotSpam: () => notSpam++, + onHide: () => hide++, + ), + ); + + expect(find.text('Filtered: you marked this as spam'), findsOneWidget); + await tester.tap(find.text('Not spam')); + await tester.tap(find.text('Hide')); + expect(notSpam, 1); + expect(hide, 1); + for (final label in ['Not spam', 'Hide']) { + final button = find.ancestor( + of: find.text(label), + matching: find.byType(TextButton), + ); + expect(tester.getSize(button).height, greaterThanOrEqualTo(48)); + } + }); + }); + + test('messageFilterReasonLabel covers every reason', () { + final l10n = AppLocalizationsEn(); + expect( + messageFilterReasonLabel(l10n, 'textRule', 'meshos'), + 'Filtered: matches "meshos"', + ); + expect( + messageFilterReasonLabel(l10n, 'senderRule', 'Bot'), + 'Filtered: sender "Bot"', + ); + expect( + messageFilterReasonLabel(l10n, 'crossSenderDuplicate', null), + 'Filtered: same message from several senders', + ); + expect( + messageFilterReasonLabel(l10n, 'unknown-reason', null), + 'Filtered: you marked this as spam', + ); + final longPattern = 'Buy cheap radios now at example dot com today'; + final label = messageFilterReasonLabel(l10n, 'textRule', longPattern); + expect(label, isNot(contains(longPattern))); + expect(label, 'Filtered: matches "Buy cheap radios now at…"'); + expect(shortFilterDetail('a\n b'), 'a b'); + for (final reason in FilterReason.values) { + expect( + messageFilterReasonLabel(l10n, filterReasonToJson(reason), 'x'), + startsWith('Filtered:'), + ); + } + }); + + group('FilteredMessageRun', () { + Widget run({required bool expanded, bool reduceMotion = false}) { + return MaterialApp( + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + home: MediaQuery( + data: MediaQueryData(disableAnimations: reduceMotion), + child: Scaffold( + body: ListView( + children: [ + FilteredMessageRun( + count: 2, + reason: 'Filtered: repeated message', + expanded: expanded, + onToggle: () {}, + buildMessages: (_) => const [ + SizedBox(height: 60, child: Text('first copy')), + SizedBox(height: 60, child: Text('second copy')), + ], + ), + ], + ), + ), + ), + ); + } + + double bodyHeight(WidgetTester tester) => + tester.getSize(find.byType(FilteredMessageRun)).height - + tester.getSize(find.byType(FilteredMessageGhost)).height; + + testWidgets('animates open and closed in place', (tester) async { + await tester.pumpWidget(run(expanded: false)); + expect(find.text('first copy'), findsNothing); + expect(bodyHeight(tester), 0); + + await tester.pumpWidget(run(expanded: true)); + await tester.pump(filteredRunAnimationDuration ~/ 2); + final midOpen = bodyHeight(tester); + expect(midOpen, greaterThan(0)); + expect(midOpen, lessThan(120)); + await tester.pumpAndSettle(); + expect(bodyHeight(tester), closeTo(120, 0.01)); + expect(find.text('first copy'), findsOneWidget); + expect( + find.text('Showing 2 hidden messages · Tap to hide'), + findsOneWidget, + ); + + await tester.pumpWidget(run(expanded: false)); + await tester.pump(filteredRunAnimationDuration ~/ 2); + final midClose = bodyHeight(tester); + expect(midClose, greaterThan(0)); + expect(midClose, lessThan(120)); + await tester.pumpAndSettle(); + expect(find.text('first copy'), findsNothing); + expect(bodyHeight(tester), 0); + }); + + testWidgets('reduced motion switches instantly', (tester) async { + await tester.pumpWidget(run(expanded: false, reduceMotion: true)); + await tester.pumpWidget(run(expanded: true, reduceMotion: true)); + await tester.pump(); + expect(bodyHeight(tester), closeTo(120, 0.01)); + await tester.pumpWidget(run(expanded: false, reduceMotion: true)); + await tester.pump(); + expect(bodyHeight(tester), 0); + }); + }); +} diff --git a/untranslated.json b/untranslated.json index e24ecc86..9e26dfee 100644 --- a/untranslated.json +++ b/untranslated.json @@ -1,103 +1 @@ -{ - "bg": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "de": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "es": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "fr": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "hu": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "it": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "ja": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "ko": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "nl": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "pl": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "pt": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "ru": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "sk": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "sl": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "sv": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "uk": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ], - - "zh": [ - "appSettings_showOnlineLinks", - "appSettings_showOnlineLinksSubtitle", - "map_showOnlineLinks" - ] -} +{} \ No newline at end of file