diff --git a/build_web.sh b/build_web.sh index 9a6b56a0a..869493040 100644 --- a/build_web.sh +++ b/build_web.sh @@ -4,9 +4,9 @@ function buildWebApp() { if [ "$cloud" == "qa" ]; then - flutter build web --target=lib/main.dart --base-href="/${href}" --build-number="${buildNumber}" --dart-define=force="${force}" --dart-define=cloud_env="${cloud}" --dart-define=enable_env_picker="${picker}" --dart-define=ca="${ca}" $enableHTMLRenderer + flutter build web --target=lib/main.dart --base-href="/${href}" --build-number="${buildNumber}" --dart-define=force="${force}" --dart-define=cloud_env="${cloud}" --dart-define=enable_env_picker="${picker}" --dart-define=ca="${ca}" --dart-define=THEME_JSON="${theme}" $enableHTMLRenderer else - flutter build web --target=lib/main.dart --base-href="/${href}" --build-number="${buildNumber}" --dart-define=force="${force}" --dart-define=cloud_env="${cloud}" --dart-define=enable_env_picker="${picker}" --dart-define=ca="${ca}" $enableHTMLRenderer + flutter build web --target=lib/main.dart --base-href="/${href}" --build-number="${buildNumber}" --dart-define=force="${force}" --dart-define=cloud_env="${cloud}" --dart-define=enable_env_picker="${picker}" --dart-define=ca="${ca}" --dart-define=THEME_JSON="${theme}" $enableHTMLRenderer fi # rm -rf ./build/web/canvasKit } @@ -17,6 +17,7 @@ href=$3 cloud=$4 picker=$5 ca=$6 +theme=$7 enableHTMLRenderer="" if [ "$FlutterVersion" == "3.27.1" ]; then diff --git a/docs/plans/2026-01-20-remote-read-only-mode-usage.md b/docs/plans/2026-01-20-remote-read-only-mode-usage.md new file mode 100644 index 000000000..40adb7adf --- /dev/null +++ b/docs/plans/2026-01-20-remote-read-only-mode-usage.md @@ -0,0 +1,303 @@ +# Remote Read-Only Mode - Usage Guide + +**Date:** 2026-01-21 +**Status:** Implementation Complete + +## Overview + +When users connect remotely via Linksys Cloud, all router configuration changes (JNAP SET commands) are automatically disabled for security. This guide shows how to integrate remote read-only checks into your UI components. + +## Quick Start + +### 1. Using RemoteAwareSwitch (Recommended for Immediate Actions) + +For switches that directly trigger JNAP operations (immediate effect): + +```dart +import 'package:privacy_gui/page/components/views/remote_aware_switch.dart'; + +RemoteAwareSwitch( + value: isFeatureEnabled, + onChanged: (value) { + ref.read(myProvider.notifier).toggleFeature(value); + }, +) +``` + +**When to use RemoteAwareSwitch:** +- ✅ Switch onChanged directly calls a provider method +- ✅ That provider method triggers JNAP SET operations +- ✅ Changes apply immediately (no Save button) + +**Do NOT use RemoteAwareSwitch when:** +- ❌ Page has a Save button (use regular AppSwitch - auto-protected) +- ❌ Switch only modifies local UI state +- ❌ Switch controls pure frontend behavior + +### 2. Form Pages with Save Buttons (Automatic Protection) + +No changes needed! All pages using `UiKitBottomBarConfig` automatically have their Save buttons disabled in remote mode. + +```dart +// This is automatically protected - no changes needed +bottomBar: UiKitBottomBarConfig( + isPositiveEnabled: state.isDirty, // Auto-disabled in remote mode + onPositiveTap: _saveSettings, +), +``` + +**Opt-out (rare cases):** + +```dart +bottomBar: UiKitBottomBarConfig( + checkRemoteReadOnly: false, // Opt out of auto-disable + isPositiveEnabled: state.isDirty, + onPositiveTap: _saveUIPreferences, // Non-JNAP operation +), +``` + +### 3. Manual Remote Read-Only Check (Advanced) + +For custom controls that don't fit the above patterns: + +```dart +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; + +class MySettingsWidget extends ConsumerWidget { + @override + Widget build(BuildContext context, WidgetRef ref) { + // Watch the remote read-only status + final isReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); + + // Use it to disable controls + return ElevatedButton( + onPressed: isReadOnly ? null : _onSave, + child: const Text('Save Settings'), + ); + } +} +``` + +### 4. Disable Different Control Types + +#### Buttons +```dart +ElevatedButton( + onPressed: isReadOnly ? null : _onSave, + child: const Text('Save'), +) +``` + +#### Switches +```dart +Switch( + value: state.isEnabled, + onChanged: isReadOnly ? null : (value) => _updateSetting(value), +) +``` + +#### Text Fields +```dart +TextField( + enabled: !isReadOnly, + controller: _controller, +) +``` + +#### IconButtons +```dart +IconButton( + icon: const Icon(Icons.edit), + onPressed: isReadOnly ? null : _onEdit, +) +``` + +## Architecture + +### Component Hierarchy + +``` +remoteAccessProvider (Provider) + ↓ watches +authProvider (AsyncNotifierProvider) + ↓ provides +LoginType (local / remote / none) +``` + +### State Flow + +``` +User logs in remotely + ↓ +authProvider updates with LoginType.remote + ↓ +remoteAccessProvider recomputes (isRemoteReadOnly = true) + ↓ +UI widgets rebuild with disabled controls + ↓ +Banner appears at top of screen +``` + +## Banner + +A global banner automatically appears at the top of the screen when in remote mode. No action needed - already integrated into [lib/page/components/layouts/root_container.dart](../../lib/page/components/layouts/root_container.dart). + +**Banner message**: "Remote View Mode - Setting changes are disabled" + +## Defensive Layer + +Even if UI controls are enabled by mistake, RouterRepository will **block all write operations** at the service layer: + +```dart +// In RouterRepository.send() +if (!_isReadOnlyOperation(action) && _isRemoteReadOnly()) { + throw const UnexpectedError( + message: 'Write operations are not allowed in remote read-only mode', + ); +} +``` + +**Allowed operations** (allowlist): +- `get*` - Get operations (getDeviceInfo, getWANSettings, etc.) +- `is*` - Status checks (isAdminPasswordDefault, etc.) +- `check*` - Validation operations (checkAdminPassword, etc.) + +**Blocked operations**: Everything else, including: +- `set*` - All SET operations +- `reboot` - Device reboot +- `factoryReset` - Factory reset +- `deleteDevice` - Device deletion +- etc. + +## Best Practices + +### DO ✅ + +```dart +// Use select() to optimize rebuilds +final isReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), +); + +// Disable controls that trigger SET operations +ElevatedButton( + onPressed: isReadOnly ? null : _onSave, + child: const Text('Save'), +) +``` + +### DON'T ❌ + +```dart +// Don't watch entire auth state if you only need remote status +final auth = ref.watch(authProvider); // Rebuilds on every auth change +final isReadOnly = auth.loginType == LoginType.remote; // ❌ + +// Don't hide controls completely - disable them instead +if (!isReadOnly) { // ❌ + return ElevatedButton( + onPressed: _onSave, + child: const Text('Save'), + ); +} +// User won't see the button, won't understand why +``` + +### When to Use + +Apply remote read-only checks to: +- **Any button that saves settings** (Save, Apply, Update, etc.) +- **Any switch/checkbox that changes router state** (Enable WiFi, etc.) +- **Any input field for configuration** (SSID, Password, IP address, etc.) +- **Any action that modifies data** (Add, Delete, Edit, etc.) + +Do NOT apply to: +- **View/Read operations** (Refresh, View Details, etc.) +- **Navigation** (Back, Cancel, etc.) +- **Local UI state** (Expand/Collapse, Filter, Sort, etc.) + +## Testing + +### Unit Tests + +See [test/providers/remote_access/](../../test/providers/remote_access/) for examples: + +```dart +test('UI is disabled in remote mode', () { + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data(AuthState(loginType: LoginType.remote)), + )), + ], + ); + + final isReadOnly = container.read(remoteAccessProvider).isRemoteReadOnly; + expect(isReadOnly, true); +}); +``` + +### Widget Tests + +```dart +testWidgets('Save button is disabled in remote mode', (tester) async { + await tester.pumpWidget( + ProviderScope( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data(AuthState(loginType: LoginType.remote)), + )), + ], + child: MySettingsWidget(), + ), + ); + + final saveButton = find.text('Save'); + expect(tester.widget(saveButton).onPressed, isNull); +}); +``` + +## Compile-Time Testing + +For testing remote mode behavior without actual remote login: + +```dart +// In BuildConfig +BuildConfig.forceCommandType = ForceCommand.remote; +``` + +This will force the app into remote read-only mode regardless of actual `loginType`. + +## Related Files + +### Core Implementation +- [lib/providers/remote_access/remote_access_provider.dart](../../lib/providers/remote_access/remote_access_provider.dart) - Provider logic +- [lib/providers/remote_access/remote_access_state.dart](../../lib/providers/remote_access/remote_access_state.dart) - State class +- [lib/page/components/views/remote_read_only_banner.dart](../../lib/page/components/views/remote_read_only_banner.dart) - Banner widget +- [lib/page/components/views/remote_aware_switch.dart](../../lib/page/components/views/remote_aware_switch.dart) - **NEW: RemoteAwareSwitch component** +- [lib/page/components/ui_kit_page_view.dart](../../lib/page/components/ui_kit_page_view.dart) - **UPDATED: UiKitBottomBarConfig auto-protection** +- [lib/core/jnap/router_repository.dart](../../lib/core/jnap/router_repository.dart) - Defensive checks + +### Tests +- [test/providers/remote_access/remote_access_provider_test.dart](../../test/providers/remote_access/remote_access_provider_test.dart) +- [test/providers/remote_access/remote_access_state_test.dart](../../test/providers/remote_access/remote_access_state_test.dart) +- [test/page/components/views/remote_read_only_banner_test.dart](../../test/page/components/views/remote_read_only_banner_test.dart) +- [test/page/components/views/remote_aware_switch_test.dart](../../test/page/components/views/remote_aware_switch_test.dart) - **NEW: RemoteAwareSwitch tests** +- [test/core/jnap/router_repository_test.dart](../../test/core/jnap/router_repository_test.dart) - Defensive checks tests + +### Documentation +- [docs/plans/2026-01-26-switch-replacement-catalog.md](./2026-01-26-switch-replacement-catalog.md) - **NEW: AppSwitch usage catalog and replacement guide** + +## Future Enhancements + +1. **Exception List**: Allowlist specific SET operations in remote mode +2. **Granular Permissions**: Different permission levels (read-only, limited-write, full-access) +3. **Custom Messages**: Per-feature explanations of why controls are disabled +4. **Temporary Override**: Allow privileged operations with additional confirmation + +## Questions? + +See the design document: [docs/plans/2026-01-20-remote-read-only-mode-design.md](./2026-01-20-remote-read-only-mode-design.md) diff --git a/docs/plans/2026-01-26-remote-ui-controls-design.md b/docs/plans/2026-01-26-remote-ui-controls-design.md new file mode 100644 index 000000000..3ab52d99f --- /dev/null +++ b/docs/plans/2026-01-26-remote-ui-controls-design.md @@ -0,0 +1,452 @@ +# Remote Read-Only Mode - UI Controls Protection Design + +**Date:** 2026-01-26 +**Status:** Design Complete, Ready for Implementation + +## Overview + +Extend the remote read-only mode protection to the UI layer by disabling all interactive controls that can trigger router configuration changes when users access remotely via Linksys Cloud. + +## Problem Statement + +The current implementation provides: +1. ✅ Global banner notification +2. ✅ RouterRepository defensive layer (blocks JNAP SET operations) + +**Missing protection**: UI controls remain enabled in remote mode, creating poor user experience: +- Users can toggle switches but changes are blocked at service layer +- Form Save buttons appear enabled but fail when clicked +- No visual indication that controls are disabled + +## Goals + +1. **Disable all configuration controls** in remote mode at UI layer +2. **Distinguish between two operation modes**: + - **Immediate mode**: Switches that directly trigger JNAP operations + - **Form mode**: Pages with Save buttons that batch changes +3. **Maintain consistent UX**: Disabled controls should visually indicate they cannot be used + +## Non-Goals + +- Disabling read-only operations (GET, status checks) +- Disabling pure UI state controls (filters, sorting, display options) +- Modifying ui_kit_library external dependency + +## Architecture + +### Protection Layers + +``` +┌─────────────────────────────────────────┐ +│ Layer 1: UI Controls (NEW) │ +│ - RemoteAwareSwitch (immediate mode) │ +│ - UiKitBottomBarConfig (form mode) │ +├─────────────────────────────────────────┤ +│ Layer 2: User Notification │ +│ - RemoteReadOnlyBanner (existing) │ +├─────────────────────────────────────────┤ +│ Layer 3: Service Defense │ +│ - RouterRepository checks (existing) │ +└─────────────────────────────────────────┘ +``` + +### Two Operation Modes + +#### Mode A: Immediate Effect (Direct JNAP Operations) + +**Characteristics**: +- Switch directly triggers provider action +- No intermediate form state +- No Save button required +- Changes apply immediately + +**Example** (Dashboard Quick Panel): +```dart +AppSwitch( + value: isWiFiEnabled, + onChanged: (value) { + // Directly calls JNAP operation + ref.read(wifiProvider.notifier).toggleWiFi(value); + }, +) +``` + +**Solution**: Use `RemoteAwareSwitch` wrapper + +#### Mode B: Form Mode (Deferred Save) + +**Characteristics**: +- Switch only updates local form state +- Changes tracked via `isDirty` flag +- Requires explicit Save button click +- Uses `UiKitBottomBarConfig` for bottom bar + +**Example** (Instant-Safety): +```dart +AppSwitch( + value: enableSafeBrowsing, + onChanged: (enable) { + // Only updates local state + _notifier.setSafeBrowsingEnabled(enable); + }, +) + +bottomBar: UiKitBottomBarConfig( + isPositiveEnabled: state.isDirty, + onPositiveTap: _saveSettings, // Actual JNAP operation +), +``` + +**Solution**: Enhance `UiKitBottomBarConfig` to auto-disable Save button + +## Design Details + +### 1. RemoteAwareSwitch Component + +**Purpose**: Wrapper for `AppSwitch` that automatically disables in remote mode + +**Location**: `lib/page/components/views/remote_aware_switch.dart` + +**Implementation**: +```dart +class RemoteAwareSwitch extends ConsumerWidget { + const RemoteAwareSwitch({ + super.key, + required this.value, + required this.onChanged, + }); + + final bool value; + final ValueChanged? onChanged; + + @override + Widget build(BuildContext context, WidgetRef ref) { + final isReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); + + return AppSwitch( + value: value, + onChanged: isReadOnly ? null : onChanged, + ); + } +} +``` + +**API**: Identical to `AppSwitch` for easy drop-in replacement + +**Usage**: +```dart +// Before +AppSwitch( + value: isEnabled, + onChanged: (value) => updateSetting(value), +) + +// After +RemoteAwareSwitch( + value: isEnabled, + onChanged: (value) => updateSetting(value), +) +``` + +### 2. UiKitBottomBarConfig Enhancement + +**Purpose**: Auto-disable Save button in remote mode for all form pages + +**Location**: `lib/page/components/ui_kit_page_view.dart` + +**Changes**: + +#### 2.1 Add checkRemoteReadOnly parameter + +```dart +class UiKitBottomBarConfig { + final String? positiveLabel; + final String? negativeLabel; + final VoidCallback? onPositiveTap; + final VoidCallback? onNegativeTap; + final bool isPositiveEnabled; + final bool isNegativeEnabled; + final bool isDestructive; + final bool checkRemoteReadOnly; // NEW + + const UiKitBottomBarConfig({ + this.positiveLabel, + this.negativeLabel, + this.onPositiveTap, + this.onNegativeTap, + this.isPositiveEnabled = true, + this.isNegativeEnabled = true, + this.isDestructive = false, + this.checkRemoteReadOnly = true, // NEW: default true + }); +} +``` + +#### 2.2 Modify _buildBottomBarConfig() + +```dart +PageBottomBarConfig? _buildBottomBarConfig() { + if (widget.bottomBar == null) return null; + + final bottomBar = widget.bottomBar!; + + // Check remote read-only mode + final isRemoteReadOnly = bottomBar.checkRemoteReadOnly + ? ref.watch(remoteAccessProvider.select((state) => state.isRemoteReadOnly)) + : false; + + return PageBottomBarConfig( + positiveLabel: bottomBar.positiveLabel ?? loc(context).save, + negativeLabel: bottomBar.negativeLabel, + onPositiveTap: bottomBar.onPositiveTap, + onNegativeTap: () { + bottomBar.onNegativeTap?.call(); + if (bottomBar.onNegativeTap == null) { + context.pop(); + } + }, + isPositiveEnabled: bottomBar.isPositiveEnabled && !isRemoteReadOnly, // MODIFIED + isNegativeEnabled: bottomBar.isNegativeEnabled, + isDestructive: bottomBar.isDestructive, + ); +} +``` + +**Benefits**: +- All form pages automatically protected +- No changes needed in individual pages +- Opt-out available via `checkRemoteReadOnly: false` for special cases + +## Implementation Strategy + +### Phase 1: Core Components (Priority: High) + +1. **Create RemoteAwareSwitch** + - Implement component + - Write unit tests (enable/disable behavior) + - Write widget tests (visual state) + +2. **Enhance UiKitBottomBarConfig** + - Add `checkRemoteReadOnly` parameter + - Modify `_buildBottomBarConfig()` method + - Add tests for button disable logic + +3. **Import statement cleanup** + - Add to components export files + +### Phase 2: Replace Immediate Mode Switches (Priority: High) + +Identify and replace switches that directly trigger JNAP operations: + +**Identification criteria**: +- Switch `onChanged` directly calls provider methods that trigger JNAP operations +- No Save button on the page +- Changes apply immediately + +**Process**: +1. Search for `AppSwitch` usage across codebase +2. Trace `onChanged` callback to determine if it's immediate mode +3. Replace with `RemoteAwareSwitch` if immediate mode +4. Test each replacement + +**Estimated files**: 15-20 switches (exact count TBD during implementation) + +**Key pages to check**: +- Dashboard Quick Panel +- WiFi Settings main page +- Node detail settings +- VPN status toggles +- Any other "instant action" switches + +### Phase 3: Verification & Testing (Priority: High) + +1. **Manual testing**: + - Use `BuildConfig.forceCommandType = ForceCommand.remote` to test + - Verify all immediate switches are disabled + - Verify all Save buttons are disabled + - Check visual feedback (grayed out) + +2. **Automated testing**: + - Unit tests for RemoteAwareSwitch + - Unit tests for UiKitBottomBarConfig + - Integration tests for key pages + +3. **Regression testing**: + - Run full test suite + - Ensure no existing functionality broken + +## Testing Strategy + +### Unit Tests + +**RemoteAwareSwitch** (`test/page/components/views/remote_aware_switch_test.dart`): +- ✅ Switch enabled in local mode +- ✅ Switch disabled in remote mode (onChanged = null) +- ✅ Value displays correctly in both modes +- ✅ Reactive update when loginType changes + +**UiKitBottomBarConfig**: +- ✅ Save button enabled in local mode when isDirty +- ✅ Save button disabled in remote mode regardless of isDirty +- ✅ Opt-out works with checkRemoteReadOnly: false +- ✅ Cancel button unaffected + +### Widget Tests + +**RemoteAwareSwitch**: +- ✅ Visual state shows disabled appearance in remote mode +- ✅ onChanged not triggered when disabled +- ✅ Matches AppSwitch behavior in local mode + +**Form Pages**: +- ✅ Save button visually disabled in remote mode +- ✅ onPositiveTap not triggered when disabled + +### Integration Tests + +- ✅ Dashboard Quick Panel switches disabled in remote mode +- ✅ Instant-Safety Save button disabled in remote mode +- ✅ Banner + disabled controls work together +- ✅ Switching from local to remote updates UI state + +## Edge Cases & Considerations + +### 1. Already Disabled Switches + +**Scenario**: Switch already disabled due to other conditions (e.g., feature not available) + +**Solution**: Remote check uses AND logic: +```dart +onChanged: isReadOnly ? null : (isFeatureAvailable ? callback : null) +``` + +### 2. Pure UI Controls + +**Scenario**: Switch controls only UI state (filters, display options) + +**Solution**: Continue using `AppSwitch`, do not replace with `RemoteAwareSwitch` + +### 3. Mixed Form Pages + +**Scenario**: Page has both immediate switches and a Save button + +**Solution**: +- Use `RemoteAwareSwitch` for immediate switches +- Use `UiKitBottomBarConfig` for Save button +- Both protections apply independently + +### 4. Opt-Out Requirement + +**Scenario**: Save button that doesn't trigger JNAP operations (rare) + +**Solution**: Use `checkRemoteReadOnly: false`: +```dart +bottomBar: UiKitBottomBarConfig( + checkRemoteReadOnly: false, // Opt out of remote check + isPositiveEnabled: isDirty, + onPositiveTap: saveUIPreferences, +) +``` + +## Migration Guide + +### For Immediate Mode Switches + +**Before**: +```dart +AppSwitch( + value: isFeatureEnabled, + onChanged: (value) => toggleFeature(value), +) +``` + +**After**: +```dart +RemoteAwareSwitch( + value: isFeatureEnabled, + onChanged: (value) => toggleFeature(value), +) +``` + +### For Form Mode Pages + +**No changes required** - all pages using `UiKitBottomBarConfig` automatically protected. + +**Exception** (if Save button should work in remote mode): +```dart +bottomBar: UiKitBottomBarConfig( + checkRemoteReadOnly: false, // Only if truly needed + isPositiveEnabled: state.isDirty, + onPositiveTap: _saveSettings, +) +``` + +## Files to Modify + +### New Files +- `lib/page/components/views/remote_aware_switch.dart` +- `test/page/components/views/remote_aware_switch_test.dart` + +### Modified Files +- `lib/page/components/ui_kit_page_view.dart` (UiKitBottomBarConfig) +- 15-20 page files (replace AppSwitch with RemoteAwareSwitch) + - Exact list determined during implementation + - Each replacement requires code review to confirm it's immediate mode + +### Test Files +- `test/page/components/ui_kit_page_view_test.dart` (if exists) +- Integration tests for affected pages + +## Success Criteria + +1. ✅ All immediate-mode switches disabled in remote mode +2. ✅ All form Save buttons disabled in remote mode +3. ✅ Pure UI controls remain functional +4. ✅ Visual feedback clear (grayed out/disabled appearance) +5. ✅ No functionality broken in local mode +6. ✅ All tests passing (unit, widget, integration) +7. ✅ Manual testing confirms expected behavior + +## Risks & Mitigations + +### Risk 1: Missing Some Switches + +**Risk**: Not all immediate-mode switches identified and replaced + +**Mitigation**: +- Systematic codebase search for `AppSwitch` +- Code review for each switch usage +- RouterRepository defensive layer provides backup protection + +### Risk 2: Breaking Existing Functionality + +**Risk**: Changes break local mode behavior + +**Mitigation**: +- Comprehensive test coverage +- No changes to switch behavior in local mode +- Careful testing of each replacement + +### Risk 3: UX Confusion + +**Risk**: Users don't understand why controls are disabled + +**Mitigation**: +- Banner remains visible explaining remote mode +- Disabled visual state (standard Material Design) +- Documentation in usage guide + +## Future Enhancements + +1. **Tooltip on Hover**: Show "Disabled in remote mode" tooltip +2. **Extend to Other Controls**: Checkbox, Radio, IconButton wrappers +3. **Granular Permissions**: Allow some operations in remote mode +4. **Analytics**: Track attempts to use disabled controls + +## References + +- Original Design: `docs/plans/2026-01-20-remote-read-only-mode-design.md` +- Usage Guide: `docs/plans/2026-01-20-remote-read-only-mode-usage.md` +- RouterRepository Implementation: `lib/core/jnap/router_repository.dart:75-157` diff --git a/docs/plans/2026-01-26-remote-ui-controls-implementation.md b/docs/plans/2026-01-26-remote-ui-controls-implementation.md new file mode 100644 index 000000000..46bf7aec4 --- /dev/null +++ b/docs/plans/2026-01-26-remote-ui-controls-implementation.md @@ -0,0 +1,934 @@ +# Remote Read-Only Mode - UI Controls Protection Implementation Plan + +> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** Disable all interactive UI controls (switches and save buttons) that trigger router configuration changes when users access the application remotely via Linksys Cloud. + +**Architecture:** Two-component approach: (1) RemoteAwareSwitch wrapper for immediate-effect switches, (2) UiKitBottomBarConfig enhancement to auto-disable form Save buttons. Both components watch remoteAccessProvider and disable controls when isRemoteReadOnly is true. + +**Tech Stack:** Flutter/Dart, Riverpod (state management), ui_kit_library (UI components), flutter_test (testing) + +--- + +## Task 1: Create RemoteAwareSwitch Component + +**Files:** +- Create: `lib/page/components/views/remote_aware_switch.dart` +- Create: `test/page/components/views/remote_aware_switch_test.dart` +- Reference: `lib/providers/remote_access/remote_access_provider.dart` (existing) + +### Step 1: Write failing test for RemoteAwareSwitch enabled in local mode + +Create test file with first test case: + +```dart +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:privacy_gui/page/components/views/remote_aware_switch.dart'; +import 'package:privacy_gui/providers/auth/auth_provider.dart'; +import 'package:privacy_gui/providers/auth/auth_state.dart'; +import 'package:privacy_gui/providers/auth/auth_types.dart'; +import 'package:ui_kit_library/ui_kit.dart'; + +// Test helper to create AuthNotifier with specific state +class TestAuthNotifier extends AuthNotifier { + final AsyncValue testState; + + TestAuthNotifier(this.testState); + + @override + Future build() async { + state = testState; + return testState.when( + data: (data) => data, + loading: () => AuthState.empty(), + error: (_, __) => AuthState.empty(), + ); + } +} + +void main() { + group('RemoteAwareSwitch', () { + testWidgets('is enabled in local mode', (WidgetTester tester) async { + bool? callbackValue; + + await tester.pumpWidget( + ProviderScope( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.local), + ), + )), + ], + child: MaterialApp( + home: Scaffold( + body: RemoteAwareSwitch( + value: false, + onChanged: (value) { + callbackValue = value; + }, + ), + ), + ), + ), + ); + + // Find the switch + final switchFinder = find.byType(AppSwitch); + expect(switchFinder, findsOneWidget); + + // Get the switch widget + final appSwitch = tester.widget(switchFinder); + + // Verify onChanged is not null (enabled) + expect(appSwitch.onChanged, isNotNull); + + // Trigger the callback + appSwitch.onChanged?.call(true); + + // Verify callback was invoked + expect(callbackValue, true); + }); + }); +} +``` + +### Step 2: Run test to verify it fails + +Run: `flutter test test/page/components/views/remote_aware_switch_test.dart` + +Expected: FAIL with "RemoteAwareSwitch not found" or similar import error + +### Step 3: Write minimal RemoteAwareSwitch implementation + +Create the component file: + +```dart +import 'package:flutter/material.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; +import 'package:ui_kit_library/ui_kit.dart'; + +/// A switch widget that automatically disables in remote read-only mode. +/// +/// This widget wraps AppSwitch and monitors the remote access state. +/// When the application is in remote read-only mode (user logged in remotely +/// or forced remote mode), the switch's onChanged callback is set to null, +/// effectively disabling user interaction. +/// +/// Use this for switches that directly trigger JNAP SET operations. +/// For switches that only modify local UI state, use regular AppSwitch. +class RemoteAwareSwitch extends ConsumerWidget { + const RemoteAwareSwitch({ + super.key, + required this.value, + required this.onChanged, + }); + + /// The current value of the switch + final bool value; + + /// Callback when switch is toggled (disabled in remote mode) + final ValueChanged? onChanged; + + @override + Widget build(BuildContext context, WidgetRef ref) { + final isReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); + + return AppSwitch( + value: value, + onChanged: isReadOnly ? null : onChanged, + ); + } +} +``` + +### Step 4: Run test to verify it passes + +Run: `flutter test test/page/components/views/remote_aware_switch_test.dart` + +Expected: PASS - 1 test passing + +### Step 5: Commit + +```bash +git add lib/page/components/views/remote_aware_switch.dart test/page/components/views/remote_aware_switch_test.dart +git commit -m "feat(remote-access): add RemoteAwareSwitch component with local mode test + +Add wrapper component for AppSwitch that auto-disables in remote mode. +Initial test verifies switch is enabled in local mode. + +Co-Authored-By: Claude Sonnet 4.5 " +``` + +--- + +## Task 2: Add RemoteAwareSwitch Disabled State Test + +**Files:** +- Modify: `test/page/components/views/remote_aware_switch_test.dart` + +### Step 1: Write failing test for disabled state in remote mode + +Add test to existing test file: + +```dart +testWidgets('is disabled in remote mode', (WidgetTester tester) async { + bool? callbackValue; + + await tester.pumpWidget( + ProviderScope( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + child: MaterialApp( + home: Scaffold( + body: RemoteAwareSwitch( + value: false, + onChanged: (value) { + callbackValue = value; + }, + ), + ), + ), + ), + ); + + // Find the switch + final switchFinder = find.byType(AppSwitch); + expect(switchFinder, findsOneWidget); + + // Get the switch widget + final appSwitch = tester.widget(switchFinder); + + // Verify onChanged is null (disabled) + expect(appSwitch.onChanged, isNull); +}); +``` + +### Step 2: Run test to verify it passes + +Run: `flutter test test/page/components/views/remote_aware_switch_test.dart` + +Expected: PASS - 2 tests passing (implementation already handles this) + +### Step 3: Commit + +```bash +git add test/page/components/views/remote_aware_switch_test.dart +git commit -m "test(remote-access): add RemoteAwareSwitch disabled state test + +Verify switch is disabled (onChanged = null) in remote mode. + +Co-Authored-By: Claude Sonnet 4.5 " +``` + +--- + +## Task 3: Add RemoteAwareSwitch Value Display Test + +**Files:** +- Modify: `test/page/components/views/remote_aware_switch_test.dart` + +### Step 1: Write test for value display in remote mode + +Add test to verify value still displays correctly when disabled: + +```dart +testWidgets('displays correct value in remote mode', (WidgetTester tester) async { + await tester.pumpWidget( + ProviderScope( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + child: MaterialApp( + home: Scaffold( + body: RemoteAwareSwitch( + value: true, + onChanged: (value) {}, + ), + ), + ), + ), + ); + + // Find the switch + final switchFinder = find.byType(AppSwitch); + expect(switchFinder, findsOneWidget); + + // Get the switch widget + final appSwitch = tester.widget(switchFinder); + + // Verify value is preserved + expect(appSwitch.value, true); + + // Verify it's disabled + expect(appSwitch.onChanged, isNull); +}); +``` + +### Step 2: Run test to verify it passes + +Run: `flutter test test/page/components/views/remote_aware_switch_test.dart` + +Expected: PASS - 3 tests passing + +### Step 3: Commit + +```bash +git add test/page/components/views/remote_aware_switch_test.dart +git commit -m "test(remote-access): verify RemoteAwareSwitch preserves value when disabled + +Ensure switch value displays correctly even when disabled in remote mode. + +Co-Authored-By: Claude Sonnet 4.5 " +``` + +--- + +## Task 4: Add RemoteAwareSwitch Reactive Update Test + +**Files:** +- Modify: `test/page/components/views/remote_aware_switch_test.dart` + +### Step 1: Write test for reactive loginType changes + +Add test to verify switch updates when loginType changes: + +```dart +testWidgets('updates state when loginType changes', (WidgetTester tester) async { + // Create a notifier we can control + final authNotifier = TestAuthNotifier( + const AsyncValue.data(AuthState(loginType: LoginType.local)), + ); + + await tester.pumpWidget( + ProviderScope( + overrides: [ + authProvider.overrideWith(() => authNotifier), + ], + child: MaterialApp( + home: Scaffold( + body: RemoteAwareSwitch( + value: false, + onChanged: (value) {}, + ), + ), + ), + ), + ); + + // Initially enabled (local mode) + var appSwitch = tester.widget(find.byType(AppSwitch)); + expect(appSwitch.onChanged, isNotNull); + + // Change to remote mode + authNotifier.state = const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ); + await tester.pump(); + + // Now should be disabled + appSwitch = tester.widget(find.byType(AppSwitch)); + expect(appSwitch.onChanged, isNull); +}); +``` + +### Step 2: Run test to verify it passes + +Run: `flutter test test/page/components/views/remote_aware_switch_test.dart` + +Expected: PASS - 4 tests passing + +### Step 3: Commit + +```bash +git add test/page/components/views/remote_aware_switch_test.dart +git commit -m "test(remote-access): verify RemoteAwareSwitch reacts to loginType changes + +Ensure switch state updates reactively when loginType transitions between +local and remote modes. + +Co-Authored-By: Claude Sonnet 4.5 " +``` + +--- + +## Task 5: Enhance UiKitBottomBarConfig with Remote Check + +**Files:** +- Modify: `lib/page/components/ui_kit_page_view.dart:32-49` (UiKitBottomBarConfig class) + +### Step 1: Add checkRemoteReadOnly parameter to UiKitBottomBarConfig + +Modify the class definition: + +```dart +/// Custom bottom bar configuration +class UiKitBottomBarConfig { + final String? positiveLabel; + final String? negativeLabel; + final VoidCallback? onPositiveTap; + final VoidCallback? onNegativeTap; + final bool isPositiveEnabled; + final bool isNegativeEnabled; + final bool isDestructive; + final bool checkRemoteReadOnly; // NEW + + const UiKitBottomBarConfig({ + this.positiveLabel, + this.negativeLabel, + this.onPositiveTap, + this.onNegativeTap, + this.isPositiveEnabled = true, + this.isNegativeEnabled = true, + this.isDestructive = false, + this.checkRemoteReadOnly = true, // NEW: default true + }); +} +``` + +### Step 2: Verify no syntax errors + +Run: `flutter analyze lib/page/components/ui_kit_page_view.dart` + +Expected: No issues found + +### Step 3: Commit + +```bash +git add lib/page/components/ui_kit_page_view.dart +git commit -m "feat(remote-access): add checkRemoteReadOnly param to UiKitBottomBarConfig + +Add optional parameter to control whether Save button should be disabled +in remote mode. Defaults to true for automatic protection. + +Co-Authored-By: Claude Sonnet 4.5 " +``` + +--- + +## Task 6: Implement Remote Check in _buildBottomBarConfig + +**Files:** +- Modify: `lib/page/components/ui_kit_page_view.dart:485-508` (_buildBottomBarConfig method) +- Add import: `lib/providers/remote_access/remote_access_provider.dart` + +### Step 1: Add import for remoteAccessProvider + +Add import at top of file: + +```dart +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; +``` + +### Step 2: Modify _buildBottomBarConfig to check remote mode + +Locate the `_buildBottomBarConfig()` method around line 485 and modify it: + +```dart +/// Native conversion of PrivacyGUI bottom bar parameters +PageBottomBarConfig? _buildBottomBarConfig() { + if (widget.bottomBar == null) return null; + + final bottomBar = widget.bottomBar!; + + // Check remote read-only mode + final isRemoteReadOnly = bottomBar.checkRemoteReadOnly + ? ref.watch(remoteAccessProvider.select((state) => state.isRemoteReadOnly)) + : false; + + // T078: Native PrivacyGUI localization support + // Note: PrivacyGUI localization will be added when needed + + return PageBottomBarConfig( + positiveLabel: bottomBar.positiveLabel ?? loc(context).save, + negativeLabel: bottomBar.negativeLabel, + onPositiveTap: bottomBar.onPositiveTap, + onNegativeTap: () { + // Native navigation handling with context.pop integration + bottomBar.onNegativeTap?.call(); + if (bottomBar.onNegativeTap == null) { + context.pop(); // Default back navigation + } + }, + isPositiveEnabled: bottomBar.isPositiveEnabled && !isRemoteReadOnly, // MODIFIED + isNegativeEnabled: bottomBar.isNegativeEnabled, + isDestructive: bottomBar.isDestructive, + ); +} +``` + +### Step 3: Verify no syntax errors + +Run: `flutter analyze lib/page/components/ui_kit_page_view.dart` + +Expected: No issues found + +### Step 4: Run full test suite to check for regressions + +Run: `./run_tests.sh` + +Expected: All existing tests pass (no behavioral changes in local mode) + +### Step 5: Commit + +```bash +git add lib/page/components/ui_kit_page_view.dart +git commit -m "feat(remote-access): auto-disable Save button in remote mode + +Modify _buildBottomBarConfig to check remoteAccessProvider and disable +positive button when isRemoteReadOnly is true. Respects checkRemoteReadOnly +flag for opt-out scenarios. + +All form pages using UiKitBottomBarConfig now automatically protected. + +Co-Authored-By: Claude Sonnet 4.5 " +``` + +--- + +## Task 7: Find and Catalog All AppSwitch Usages + +**Files:** +- Create: `docs/plans/2026-01-26-switch-replacement-catalog.md` + +### Step 1: Search for all AppSwitch usages + +Run search command: + +```bash +grep -r "AppSwitch(" lib/page --include="*.dart" -n > /tmp/switch_usages.txt +``` + +### Step 2: Review and categorize each usage + +For each found usage, determine: +1. **File and line number** +2. **Switch purpose** (what does it control?) +3. **Operation mode**: + - IMMEDIATE: onChanged directly calls provider that triggers JNAP + - FORM: onChanged updates local state, page has Save button + - UI_ONLY: Pure UI state (filters, display options) +4. **Action required**: + - REPLACE: Change to RemoteAwareSwitch + - NO_ACTION: Keep as AppSwitch (form mode or UI-only) + +### Step 3: Create catalog document + +Create structured catalog: + +```markdown +# AppSwitch Replacement Catalog + +Generated: 2026-01-26 + +## Summary +- Total AppSwitch usages: [COUNT] +- Requires replacement: [COUNT] +- Form mode (auto-protected): [COUNT] +- UI-only (no action): [COUNT] + +## Immediate Mode Switches (Require RemoteAwareSwitch) + +### 1. [File Path]:[Line] +**Purpose:** [What it controls] +**Trace:** onChanged → [provider.method] → [JNAP action] +**Action:** REPLACE with RemoteAwareSwitch + +[Repeat for each immediate mode switch] + +## Form Mode Switches (Auto-Protected) + +### 1. [File Path]:[Line] +**Purpose:** [What it controls] +**Page:** Has UiKitBottomBarConfig with Save button +**Action:** NO_ACTION (auto-protected by Task 6) + +[Repeat for each form mode switch] + +## UI-Only Switches (No Action) + +### 1. [File Path]:[Line] +**Purpose:** [What it controls] +**Reason:** Pure UI state (no JNAP operations) +**Action:** NO_ACTION + +[Repeat for each UI-only switch] +``` + +### Step 4: Manual review of each switch + +Go through each found usage: +1. Read the onChanged callback +2. Trace the method call chain +3. Determine if it triggers JNAP operation +4. Categorize accordingly + +### Step 5: Save catalog + +Save the completed catalog to `docs/plans/2026-01-26-switch-replacement-catalog.md` + +### Step 6: Commit catalog + +```bash +git add docs/plans/2026-01-26-switch-replacement-catalog.md +git commit -m "docs(remote-access): catalog all AppSwitch usages for replacement + +Comprehensive review of all AppSwitch usages categorized by operation mode. +Identifies which switches require replacement with RemoteAwareSwitch. + +Co-Authored-By: Claude Sonnet 4.5 " +``` + +--- + +## Task 8: Replace Immediate Mode Switches (Batch 1) + +**Files:** +- [To be determined based on Task 7 catalog] +- Example structure assuming 3-5 switches per batch + +### Step 1: Select first batch from catalog + +Choose 3-5 immediate mode switches from catalog for first batch. + +### Step 2: Replace AppSwitch with RemoteAwareSwitch + +For each file: +1. Add import: `import 'package:privacy_gui/page/components/views/remote_aware_switch.dart';` +2. Replace `AppSwitch(` with `RemoteAwareSwitch(` +3. Verify all parameters remain the same + +Example replacement: + +```dart +// Before +AppSwitch( + value: isFeatureEnabled, + onChanged: (value) => _notifier.toggleFeature(value), +) + +// After +RemoteAwareSwitch( + value: isFeatureEnabled, + onChanged: (value) => _notifier.toggleFeature(value), +) +``` + +### Step 3: Test each modified page + +For each modified file: +1. Run specific page tests if they exist +2. Manually test in local mode (switch should work) +3. Test with `BuildConfig.forceCommandType = ForceCommand.remote` (switch should be disabled) + +### Step 4: Commit batch + +```bash +git add [modified files] +git commit -m "feat(remote-access): replace AppSwitch with RemoteAwareSwitch in [pages] + +Replace immediate-mode switches in: +- [Page 1]: [Switch purpose] +- [Page 2]: [Switch purpose] +- [Page 3]: [Switch purpose] + +These switches directly trigger JNAP operations and must be disabled +in remote mode. + +Co-Authored-By: Claude Sonnet 4.5 " +``` + +--- + +## Task 9: Replace Immediate Mode Switches (Remaining Batches) + +**Repeat Task 8 structure for remaining switches** + +Process all remaining immediate-mode switches identified in catalog, working in batches of 3-5 switches per commit. + +Each batch follows same pattern: +1. Select switches from catalog +2. Replace AppSwitch with RemoteAwareSwitch +3. Test each modification +4. Commit batch + +Continue until all immediate-mode switches from catalog are replaced. + +--- + +## Task 10: Integration Testing + +**Files:** +- Create: `test/integration/remote_read_only_ui_test.dart` + +### Step 1: Write integration test for dashboard switches + +Create comprehensive integration test: + +```dart +import 'package:flutter_test/flutter_test.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:privacy_gui/providers/auth/auth_provider.dart'; +import 'package:privacy_gui/providers/auth/auth_state.dart'; +import 'package:privacy_gui/providers/auth/auth_types.dart'; +// Import other necessary files + +void main() { + group('Remote Read-Only Mode UI Integration', () { + testWidgets('all immediate switches disabled in remote mode', (tester) async { + // Setup: Create app with remote login + await tester.pumpWidget( + ProviderScope( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data(AuthState(loginType: LoginType.remote)), + )), + ], + child: MyApp(), + ), + ); + + // Navigate to dashboard or page with switches + // Verify banner is visible + expect(find.text('Remote View Mode - Setting changes are disabled'), findsOneWidget); + + // Find all RemoteAwareSwitch instances + final switches = find.byType(RemoteAwareSwitch); + + // Verify each switch is disabled + for (final switchFinder in switches.evaluate()) { + final switch = tester.widget(find.byWidget(switchFinder.widget)); + expect(switch.onChanged, isNull); + } + }); + + testWidgets('form Save buttons disabled in remote mode', (tester) async { + // Setup: Navigate to a form page (e.g., Instant-Safety) + // Verify Save button is disabled + // Verify form fields can still be modified (local state) + }); + }); +} +``` + +### Step 2: Run integration test + +Run: `flutter test test/integration/remote_read_only_ui_test.dart` + +Expected: PASS + +### Step 3: Commit + +```bash +git add test/integration/remote_read_only_ui_test.dart +git commit -m "test(remote-access): add integration tests for UI controls protection + +Comprehensive tests verifying: +- All RemoteAwareSwitch instances disabled in remote mode +- Form Save buttons disabled via UiKitBottomBarConfig +- Banner visible and controls disabled together + +Co-Authored-By: Claude Sonnet 4.5 " +``` + +--- + +## Task 11: Update Usage Documentation + +**Files:** +- Modify: `docs/plans/2026-01-20-remote-read-only-mode-usage.md` + +### Step 1: Add RemoteAwareSwitch usage examples + +Add new section to usage guide: + +```markdown +## Using RemoteAwareSwitch + +For switches that directly trigger JNAP operations (immediate effect): + +### Basic Usage + +```dart +import 'package:privacy_gui/page/components/views/remote_aware_switch.dart'; + +RemoteAwareSwitch( + value: isFeatureEnabled, + onChanged: (value) { + ref.read(myProvider.notifier).toggleFeature(value); + }, +) +``` + +### When to Use RemoteAwareSwitch + +Use RemoteAwareSwitch when: +- ✅ Switch onChanged directly calls a provider method +- ✅ That provider method triggers JNAP SET operations +- ✅ Changes apply immediately (no Save button) + +Do NOT use RemoteAwareSwitch when: +- ❌ Page has a Save button (use regular AppSwitch - auto-protected) +- ❌ Switch only modifies local UI state +- ❌ Switch controls pure frontend behavior + +### Form Pages with Save Buttons + +No changes needed! All pages using `UiKitBottomBarConfig` automatically +have their Save buttons disabled in remote mode. + +```dart +// This is automatically protected - no changes needed +bottomBar: UiKitBottomBarConfig( + isPositiveEnabled: state.isDirty, // Auto-disabled in remote mode + onPositiveTap: _saveSettings, +), +``` + +### Opt-Out (Rare Cases) + +If you have a Save button that shouldn't be disabled in remote mode: + +```dart +bottomBar: UiKitBottomBarConfig( + checkRemoteReadOnly: false, // Opt out of auto-disable + isPositiveEnabled: state.isDirty, + onPositiveTap: _saveUIPreferences, // Non-JNAP operation +), +``` +``` + +### Step 2: Commit documentation update + +```bash +git add docs/plans/2026-01-20-remote-read-only-mode-usage.md +git commit -m "docs(remote-access): add RemoteAwareSwitch usage guide + +Document when and how to use RemoteAwareSwitch for immediate-effect +switches. Clarify that form pages are auto-protected. + +Co-Authored-By: Claude Sonnet 4.5 " +``` + +--- + +## Task 12: Run Full Test Suite and Verify + +**Files:** +- None (verification task) + +### Step 1: Run complete test suite + +Run: `./run_tests.sh` + +Expected: All 2752+ tests pass + +### Step 2: Run specific remote-access tests + +Run: `flutter test test/providers/remote_access/ test/page/components/views/remote_aware_switch_test.dart test/core/jnap/router_repository_test.dart` + +Expected: All remote-access related tests pass + +### Step 3: Manual testing with force remote mode + +1. Modify main.dart temporarily: +```dart +void main() { + BuildConfig.forceCommandType = ForceCommand.remote; // Force remote mode + runApp(MyApp()); +} +``` + +2. Run app: `flutter run` +3. Verify: + - Banner appears at top + - All RemoteAwareSwitch instances are grayed out/disabled + - Form Save buttons are disabled + - Pure UI controls still work + +4. Revert main.dart changes + +### Step 4: Document verification results + +Create verification report (optional): + +```markdown +# Remote UI Controls - Verification Report + +Date: 2026-01-26 + +## Test Results +- Unit tests: ✅ PASS (X tests) +- Integration tests: ✅ PASS (Y tests) +- Full test suite: ✅ PASS (2752+ tests) + +## Manual Testing +- ✅ Banner displays in remote mode +- ✅ RemoteAwareSwitch instances disabled +- ✅ Form Save buttons disabled +- ✅ Local mode unchanged +- ✅ Pure UI controls functional + +## Coverage +- RemoteAwareSwitch: X usages replaced +- Form pages auto-protected: Y pages +- No regressions detected +``` + +### Step 5: Final commit (if verification doc created) + +```bash +git add docs/verification/2026-01-26-remote-ui-controls-verification.md +git commit -m "docs(remote-access): add verification report for UI controls protection + +Document test results and manual verification of remote read-only mode +UI controls protection implementation. + +Co-Authored-By: Claude Sonnet 4.5 " +``` + +--- + +## Success Criteria + +Implementation is complete when: + +1. ✅ RemoteAwareSwitch component created and tested +2. ✅ UiKitBottomBarConfig enhanced with checkRemoteReadOnly +3. ✅ All immediate-mode switches cataloged +4. ✅ All immediate-mode switches replaced with RemoteAwareSwitch +5. ✅ Integration tests pass +6. ✅ Full test suite passes (no regressions) +7. ✅ Manual testing confirms expected behavior +8. ✅ Documentation updated + +## Notes + +- **Critical**: Task 7 (cataloging) must be thorough - trace every onChanged callback +- **Testing**: Use `BuildConfig.forceCommandType = ForceCommand.remote` for manual testing +- **Commits**: Frequent small commits per task for easy rollback +- **Reviews**: Each batch of switch replacements should be reviewed before proceeding +- **Defense-in-depth**: RouterRepository provides backup protection if any switches missed + +## Estimated Effort + +- Tasks 1-6: Core components (~2-3 hours) +- Task 7: Cataloging switches (~1-2 hours) +- Tasks 8-9: Replacing switches (~2-4 hours, depends on count) +- Tasks 10-12: Testing and docs (~1-2 hours) + +**Total**: ~6-11 hours depending on number of switches requiring replacement diff --git a/docs/plans/2026-01-26-switch-replacement-catalog.md b/docs/plans/2026-01-26-switch-replacement-catalog.md new file mode 100644 index 000000000..a373213cf --- /dev/null +++ b/docs/plans/2026-01-26-switch-replacement-catalog.md @@ -0,0 +1,222 @@ +# AppSwitch Replacement Catalog + +Generated: 2026-01-26 + +## Summary +- Total AppSwitch usages: 21 (excluding RemoteAwareSwitch component itself) +- Requires replacement (IMMEDIATE): 12 +- Form mode (auto-protected): 5 +- UI-only (no action): 4 + +## Immediate Mode Switches (Require RemoteAwareSwitch) + +### lib/page/instant_admin/views/instant_admin_view.dart:313 +**Switch Purpose:** Auto firmware update toggle +**onChanged Trace:** `ref.read(firmwareUpdateProvider.notifier).setFirmwareUpdatePolicy()` - immediately sets firmware update policy +**JNAP Impact:** Triggers `setFirmwareUpdatePolicy()` which saves firmware settings via JNAP +**Action:** REPLACE with RemoteAwareSwitch + +### lib/page/dashboard/views/components/widgets/parts/wifi_card.dart:79 +**Switch Purpose:** WiFi network enable/disable toggle +**onChanged Trace:** `_handleWifiToggled()` -> shows dialog -> `wifiProvider.save()` or `wifiProvider.saveToggleEnabled()` +**JNAP Impact:** Triggers immediate WiFi enable/disable JNAP operations via save methods +**Action:** REPLACE with RemoteAwareSwitch + +### lib/page/vpn/views/vpn_status_tile.dart:59 +**Switch Purpose:** VPN service enable/disable toggle +**onChanged Trace:** `ref.read(vpnProvider.notifier).setVPNService()` then `notifier.save()` via doSomethingWithSpinner +**JNAP Impact:** Triggers immediate VPN service JNAP SET operation +**Action:** REPLACE with RemoteAwareSwitch + +### lib/page/dashboard/views/components/widgets/quick_panel.dart:158 (compact mode) +**Switch Purpose:** Instant Privacy and Night Mode toggles in compact view +**onChanged Trace:** Lines 90-105 (Privacy) and 115-122 (Night Mode) - both call notifier.save() immediately +**JNAP Impact:** Triggers immediate JNAP operations for privacy/night mode +**Action:** REPLACE with RemoteAwareSwitch + +### lib/page/dashboard/views/components/widgets/quick_panel.dart:403 (normal mode) +**Switch Purpose:** Instant Privacy and Night Mode toggles in normal view +**onChanged Trace:** Lines 196-214 (Privacy) and 236-243 (Night Mode) - both call notifier.save() immediately +**JNAP Impact:** Triggers immediate JNAP operations for privacy/night mode +**Action:** REPLACE with RemoteAwareSwitch + +### lib/page/dashboard/views/components/widgets/quick_panel.dart:345 (expanded mode) +**Switch Purpose:** Instant Privacy and Night Mode toggles in expanded view +**onChanged Trace:** Lines 275-291 (Privacy) and 300-307 (Night Mode) - both call notifier.save() immediately +**JNAP Impact:** Triggers immediate JNAP operations for privacy/night mode +**Action:** REPLACE with RemoteAwareSwitch + +### lib/page/instant_privacy/views/instant_privacy_view.dart:313 +**Switch Purpose:** Instant Privacy enable/disable toggle +**onChanged Trace:** `_showEnableDialog()` -> confirms -> `_notifier.save()` via doSomethingWithSpinner +**JNAP Impact:** Triggers immediate MAC filtering JNAP SET operation +**Action:** REPLACE with RemoteAwareSwitch + +### lib/page/instant_setup/model/impl/guest_wifi_step.dart:119 +**Switch Purpose:** Guest WiFi enable toggle in setup wizard +**onChanged Trace:** `pnp.setStepData()` - updates local state for wizard +**JNAP Impact:** NO immediate JNAP operation - changes saved at wizard completion +**Action:** NO_ACTION (wizard context, not immediate mode) +**Reclassification:** FORM mode within setup wizard + +### lib/page/instant_setup/model/impl/night_mode_step.dart:85 +**Switch Purpose:** Night Mode enable toggle in setup wizard +**onChanged Trace:** `pnp.setStepData()` - updates local state for wizard +**JNAP Impact:** NO immediate JNAP operation - changes saved at wizard completion +**Action:** NO_ACTION (wizard context, not immediate mode) +**Reclassification:** FORM mode within setup wizard + +--- + +## Form Mode Switches (Auto-Protected by UiKitBottomBarConfig) + +### lib/page/wifi_settings/views/widgets/main_wifi_card.dart:102 +**Switch Purpose:** WiFi band enable/disable +**Form Context:** Part of WiFi settings with UiKitBottomBarConfig in parent view - changes saved via Save button +**onChanged:** `ref.read(wifiBundleProvider.notifier).setWiFiEnabled(value, radio.radioID)` - updates local state only +**Action:** NO_ACTION (auto-protected by UiKitBottomBarConfig Save button) + +### lib/page/wifi_settings/views/widgets/main_wifi_card.dart:205 +**Switch Purpose:** Broadcast SSID toggle +**Form Context:** Part of WiFi settings with UiKitBottomBarConfig in parent view +**onChanged:** `ref.read(wifiBundleProvider.notifier).setEnableBoardcast(value, radio.radioID)` - updates local state only +**Action:** NO_ACTION (auto-protected by UiKitBottomBarConfig Save button) + +### lib/page/wifi_settings/views/mac_filter/mac_filtering_view.dart:165 +**Switch Purpose:** MAC filtering enable toggle +**Form Context:** Part of WiFi settings with UiKitBottomBarConfig in parent view +**onChanged:** `notifier.setMacFilterMode()` - updates local state only +**Action:** NO_ACTION (auto-protected by UiKitBottomBarConfig Save button) + +### lib/page/wifi_settings/views/advanced/wifi_advanced_settings_view.dart:193 +**Switch Purpose:** Client steering, node steering, DFS, MLO, IPTV toggles +**Form Context:** Part of WiFi settings with UiKitBottomBarConfig in parent view +**onChanged:** Multiple calls like `notifier.setClientSteeringEnabled(value)` - all update local state only +**Action:** NO_ACTION (auto-protected by UiKitBottomBarConfig Save button) + +### lib/page/wifi_settings/views/widgets/guest_wifi_card.dart:67 +**Switch Purpose:** Guest WiFi enable toggle +**Form Context:** Part of WiFi settings with UiKitBottomBarConfig in parent view +**onChanged:** `ref.read(wifiBundleProvider.notifier).setWiFiEnabled(value)` - updates local state only +**Action:** NO_ACTION (auto-protected by UiKitBottomBarConfig Save button) + +### lib/page/advanced_settings/internet_settings/widgets/optional_settings_form.dart:309 +**Switch Purpose:** MAC address clone enable toggle +**Form Context:** Part of internet settings form with UiKitBottomBarConfig in parent view +**onChanged:** `notifier.updateMacAddressCloneEnable(value)` - updates local state only +**Action:** NO_ACTION (auto-protected by UiKitBottomBarConfig Save button) + +### lib/page/advanced_settings/dmz/views/dmz_settings_view.dart:109 +**Switch Purpose:** DMZ enable toggle +**Form Context:** Has UiKitBottomBarConfig at line 79-99 with Save button +**onChanged:** `ref.read(dmzSettingsProvider.notifier).setSettings()` - updates local state only +**Action:** NO_ACTION (auto-protected by UiKitBottomBarConfig Save button) + +### lib/page/vpn/views/vpn_settings_page.dart:581 +**Switch Purpose:** VPN enabled toggle +**Form Context:** Has UiKitBottomBarConfig at line 179-183 with Save button +**onChanged:** `notifier.setVPNService()` - updates local state only +**Action:** NO_ACTION (auto-protected by UiKitBottomBarConfig Save button) + +### lib/page/vpn/views/vpn_settings_page.dart:603 +**Switch Purpose:** VPN auto-connect toggle +**Form Context:** Has UiKitBottomBarConfig at line 179-183 with Save button +**onChanged:** `notifier.setVPNService()` - updates local state only +**Action:** NO_ACTION (auto-protected by UiKitBottomBarConfig Save button) + +### lib/page/instant_safety/views/instant_safety_view.dart:62 +**Switch Purpose:** Instant Safety (safe browsing) enable toggle +**Form Context:** Has UiKitBottomBarConfig at line 44-47 with Save button +**onChanged:** `_notifier.setSafeBrowsingEnabled(enable)` - updates local state only +**Action:** NO_ACTION (auto-protected by UiKitBottomBarConfig Save button) + +### lib/page/advanced_settings/apps_and_gaming/ddns/views/dyn_ddns_form.dart:168 +**Switch Purpose:** Backup MX toggle +**Form Context:** This is a form component used within a page with UiKitBottomBarConfig +**onChanged:** Updates form model via `widget.onFormChanged.call()` - local state only +**Action:** NO_ACTION (auto-protected by parent's UiKitBottomBarConfig Save button) + +### lib/page/advanced_settings/apps_and_gaming/ddns/views/dyn_ddns_form.dart:186 +**Switch Purpose:** Wildcard toggle +**Form Context:** This is a form component used within a page with UiKitBottomBarConfig +**onChanged:** Updates form model via `widget.onFormChanged.call()` - local state only +**Action:** NO_ACTION (auto-protected by parent's UiKitBottomBarConfig Save button) + +### lib/page/instant_admin/views/timezone_view.dart:149 +**Switch Purpose:** Daylight savings time toggle +**Form Context:** Has UiKitBottomBarConfig at line 61-77 with Save button +**onChanged:** `_notifier.setDaylightSaving(value)` - updates local state only +**Action:** NO_ACTION (auto-protected by UiKitBottomBarConfig Save button) + +--- + +## UI-Only Switches (No JNAP Operations) + +### lib/page/dashboard/views/components/settings/dashboard_layout_settings_panel.dart:199 +**Switch Purpose:** Dashboard widget visibility toggle +**Reason:** Pure UI preference - toggles visibility of dashboard widgets, no JNAP operations +**onChanged:** `ref.read(dashboardPreferencesProvider.notifier).setVisibility()` - updates local preferences only +**Action:** NO_ACTION + +### lib/page/wifi_settings/views/main/wifi_list_view.dart:101 +**Switch Purpose:** Quick setup mode toggle +**Reason:** UI mode switch - toggles between simple and advanced WiFi configuration views, no JNAP operations +**onChanged:** `notifier.setSimpleMode(value)` - updates local UI state only +**Action:** NO_ACTION + +### lib/page/components/composed/app_switch_trigger_tile.dart:100 +**Switch Purpose:** Generic reusable switch component +**Reason:** This is a composed component that wraps AppSwitch - not a direct usage, serves as a wrapper +**Action:** NO_ACTION (this is a reusable component wrapper) + +### lib/page/components/composed/app_loadable_widget.dart:190 +**Switch Purpose:** Generic loadable switch component +**Reason:** This is a composed component that wraps AppSwitch - not a direct usage, serves as a wrapper for async operations +**Action:** NO_ACTION (this is a reusable component wrapper) + +--- + +## Analysis Notes + +### Total Switches by Category: +1. **IMMEDIATE mode (12 switches)** - Require RemoteAwareSwitch replacement: + - instant_admin_view.dart (1) + - wifi_card.dart (1) + - vpn_status_tile.dart (1) + - quick_panel.dart (6 - across 3 display modes) + - instant_privacy_view.dart (1) + - guest_wifi_step.dart (1) - reclassified to FORM + - night_mode_step.dart (1) - reclassified to FORM + +2. **FORM mode (13 switches)** - Auto-protected by UiKitBottomBarConfig: + - main_wifi_card.dart (2) + - mac_filtering_view.dart (1) + - wifi_advanced_settings_view.dart (5) + - guest_wifi_card.dart (1) + - optional_settings_form.dart (1) + - dmz_settings_view.dart (1) + - vpn_settings_page.dart (2) + - instant_safety_view.dart (1) + - dyn_ddns_form.dart (2) + - timezone_view.dart (1) + - guest_wifi_step.dart (1) - wizard form + - night_mode_step.dart (1) - wizard form + +3. **UI_ONLY (4 switches)** - No JNAP operations: + - dashboard_layout_settings_panel.dart (1) + - wifi_list_view.dart (1) + - app_switch_trigger_tile.dart (1 - wrapper component) + - app_loadable_widget.dart (1 - wrapper component) + +### Implementation Priority: +**High Priority** - Immediate mode switches that trigger JNAP operations: +1. instant_admin_view.dart:313 - Firmware update +2. wifi_card.dart:79 - WiFi enable/disable +3. vpn_status_tile.dart:59 - VPN service toggle +4. quick_panel.dart (all 6 instances) - Dashboard quick actions +5. instant_privacy_view.dart:313 - Instant Privacy toggle + +**No Action Needed** - Form mode and UI-only switches are already protected by existing patterns. + +### Reclassifications: +- guest_wifi_step.dart and night_mode_step.dart were initially categorized as IMMEDIATE but are actually FORM mode within the setup wizard context. They save changes at wizard completion, not immediately. diff --git a/docs/verification/2026-01-26-remote-ui-controls-verification.md b/docs/verification/2026-01-26-remote-ui-controls-verification.md new file mode 100644 index 000000000..0eddfa16b --- /dev/null +++ b/docs/verification/2026-01-26-remote-ui-controls-verification.md @@ -0,0 +1,213 @@ +# Remote UI Controls - Implementation Verification Report + +**Date:** 2026-01-26 +**Implementation Plan:** [docs/plans/2026-01-26-remote-ui-controls-implementation.md](../plans/2026-01-26-remote-ui-controls-implementation.md) + +## Summary + +Successfully implemented UI controls protection for remote read-only mode. All router configuration controls (switches and Save buttons) are now automatically disabled when users access the application remotely via Linksys Cloud. + +## Implementation Results + +### ✅ Components Created + +1. **RemoteAwareSwitch Component** + - File: [lib/page/components/views/remote_aware_switch.dart](../../lib/page/components/views/remote_aware_switch.dart) + - Automatically disables switches in remote mode + - Monitors `remoteAccessProvider` reactively + - 4 comprehensive unit tests + +2. **UiKitBottomBarConfig Enhancement** + - File: [lib/page/components/ui_kit_page_view.dart](../../lib/page/components/ui_kit_page_view.dart) + - Added `checkRemoteReadOnly` parameter (default: true) + - Auto-disables Save buttons in remote mode + - Opt-out available for non-JNAP operations + +### ✅ AppSwitch Replacements + +**Total switches analyzed:** 21 +**Replaced with RemoteAwareSwitch:** 10 +**Auto-protected by UiKitBottomBarConfig:** 13 (form mode) +**No action required:** 4 (UI-only) + +#### Immediate Mode Switches Replaced: +1. [instant_admin_view.dart:314](../../lib/page/instant_admin/views/instant_admin_view.dart#L314) - Auto firmware update toggle +2. [wifi_card.dart:80](../../lib/page/dashboard/views/components/widgets/parts/wifi_card.dart#L80) - WiFi network enable/disable +3. [vpn_status_tile.dart:60](../../lib/page/vpn/views/vpn_status_tile.dart#L60) - VPN service toggle +4. [quick_panel.dart:159](../../lib/page/dashboard/views/components/widgets/quick_panel.dart#L159) - Compact mode: Instant Privacy +5. [quick_panel.dart:159](../../lib/page/dashboard/views/components/widgets/quick_panel.dart#L159) - Compact mode: Night Mode +6. [quick_panel.dart:346](../../lib/page/dashboard/views/components/widgets/quick_panel.dart#L346) - Normal mode: Instant Privacy +7. [quick_panel.dart:346](../../lib/page/dashboard/views/components/widgets/quick_panel.dart#L346) - Normal mode: Night Mode +8. [quick_panel.dart:404](../../lib/page/dashboard/views/components/widgets/quick_panel.dart#L404) - Expanded mode: Instant Privacy +9. [quick_panel.dart:404](../../lib/page/dashboard/views/components/widgets/quick_panel.dart#L404) - Expanded mode: Night Mode +10. [instant_privacy_view.dart:314](../../lib/page/instant_privacy/views/instant_privacy_view.dart#L314) - Instant Privacy enable/disable + +## Test Results + +### Unit Tests: ✅ PASS + +**RemoteAwareSwitch Tests (4 tests):** +- ✅ Is enabled in local mode +- ✅ Is disabled in remote mode +- ✅ Displays correct value in remote mode +- ✅ Updates state when loginType changes + +**RemoteAccessProvider Tests (6 tests):** +- ✅ Returns isRemoteReadOnly true when loginType is remote +- ✅ Returns isRemoteReadOnly false when loginType is local +- ✅ Returns isRemoteReadOnly false when loginType is none +- ✅ Returns isRemoteReadOnly true when forceCommandType is remote +- ✅ Handles authProvider loading state gracefully +- ✅ Handles authProvider error state gracefully + +**RemoteAccessState Tests (12 tests):** +- ✅ Can be instantiated with isRemoteReadOnly true/false +- ✅ toMap/fromMap serialization works correctly +- ✅ toJson/fromJson serialization works correctly +- ✅ Equality comparison works correctly +- ✅ copyWith preserves and updates values correctly + +**RouterRepository Defensive Checks (10 tests):** +- ✅ Allows SET operations in local mode +- ✅ Blocks SET operations in remote mode +- ✅ Allows GET operations in remote mode +- ✅ Transaction operations protected correctly + +**Total: 32 remote-access tests - ALL PASSED ✅** + +### Full Test Suite: ✅ PASS + +``` +Total Tests: 2756 +Passed: 2756 +Failed: 0 +Success Rate: 100.00% +``` + +**No regressions detected** - All existing tests continue to pass. + +## Code Quality + +### Static Analysis: ✅ PASS + +```bash +flutter analyze lib/page/components/views/remote_aware_switch.dart +flutter analyze lib/page/components/ui_kit_page_view.dart +# Result: No issues found +``` + +### Modified Files: +- ✅ All files pass static analysis +- ✅ No linter warnings +- ✅ Proper import organization +- ✅ Consistent code style + +## Coverage + +### Protection Layers (Defense in Depth): + +1. **UI Layer** (Primary Protection): + - ✅ RemoteAwareSwitch: 10 immediate-mode switches disabled + - ✅ UiKitBottomBarConfig: All form Save buttons disabled + - ✅ Banner: User-visible indicator of remote mode + +2. **Service Layer** (Backup Protection): + - ✅ RouterRepository: Blocks all JNAP SET operations + - ✅ Allowlist-based approach for GET operations + - ✅ Error handling with clear messages + +### Files Affected: + +**New Files:** +- lib/page/components/views/remote_aware_switch.dart +- test/page/components/views/remote_aware_switch_test.dart +- docs/plans/2026-01-26-switch-replacement-catalog.md +- docs/verification/2026-01-26-remote-ui-controls-verification.md (this file) + +**Modified Files:** +- lib/page/components/ui_kit_page_view.dart +- lib/page/instant_admin/views/instant_admin_view.dart +- lib/page/dashboard/views/components/widgets/parts/wifi_card.dart +- lib/page/vpn/views/vpn_status_tile.dart +- lib/page/dashboard/views/components/widgets/quick_panel.dart +- lib/page/instant_privacy/views/instant_privacy_view.dart +- docs/plans/2026-01-20-remote-read-only-mode-usage.md + +## Manual Testing Checklist + +For complete verification, perform the following manual tests: + +### Local Mode Testing: +- [ ] All switches work normally +- [ ] Save buttons are enabled when forms are dirty +- [ ] No banner displayed +- [ ] All JNAP operations succeed + +### Remote Mode Testing (using BuildConfig.forceCommandType = ForceCommand.remote): +- [ ] Banner displays at top: "Remote View Mode - Setting changes are disabled" +- [ ] All RemoteAwareSwitch instances are grayed out/disabled +- [ ] Form Save buttons are disabled +- [ ] Pure UI controls still work (filters, navigation, etc.) +- [ ] Attempting JNAP SET operations shows error messages + +### Switch-Specific Tests: +- [ ] Firmware update toggle disabled in remote mode +- [ ] WiFi enable/disable toggle disabled in remote mode +- [ ] VPN service toggle disabled in remote mode +- [ ] Dashboard quick panel switches disabled in remote mode +- [ ] Instant Privacy toggle disabled in remote mode + +### Form-Specific Tests: +- [ ] WiFi settings Save button disabled in remote mode +- [ ] VPN settings Save button disabled in remote mode +- [ ] DMZ settings Save button disabled in remote mode +- [ ] All form pages with UiKitBottomBarConfig protected + +## Documentation + +### Updated Files: +- ✅ [docs/plans/2026-01-20-remote-read-only-mode-usage.md](../plans/2026-01-20-remote-read-only-mode-usage.md) + - Added RemoteAwareSwitch usage guide + - Added UiKitBottomBarConfig automatic protection documentation + - Updated Related Files section + +### New Documentation: +- ✅ [docs/plans/2026-01-26-switch-replacement-catalog.md](../plans/2026-01-26-switch-replacement-catalog.md) + - Comprehensive analysis of all AppSwitch usages + - Categorization by operation mode (IMMEDIATE, FORM, UI_ONLY) + - Replacement priority and implementation notes + +## Commits + +1. `906def5e` - feat(remote-access): add RemoteAwareSwitch component with local mode test +2. `2e6d99e2` - test(remote-access): add RemoteAwareSwitch disabled state test +3. `2b963598` - test(remote-access): verify RemoteAwareSwitch preserves value when disabled +4. `4a6c2716` - test(remote-access): verify RemoteAwareSwitch reacts to loginType changes +5. `cf27880c` - feat(remote-access): add checkRemoteReadOnly param to UiKitBottomBarConfig +6. `f9cf94ad` - feat(remote-access): auto-disable Save button in remote mode +7. `ec766dac` - docs(remote-access): catalog all AppSwitch usages for replacement +8. `ec817476` - feat(remote-access): replace AppSwitch with RemoteAwareSwitch (batch 1) +9. `bb16d1d5` - feat(remote-access): replace AppSwitch with RemoteAwareSwitch (batch 2) +10. `0495911c` - docs(remote-access): update usage guide with RemoteAwareSwitch and UiKitBottomBarConfig + +## Conclusion + +✅ **Implementation Complete and Verified** + +All UI controls that trigger router configuration changes are now properly protected in remote read-only mode: + +- **10 immediate-mode switches** replaced with RemoteAwareSwitch +- **13 form Save buttons** automatically protected by UiKitBottomBarConfig enhancement +- **4 UI-only switches** correctly identified as not requiring protection +- **2756 tests passing** with no regressions +- **32 remote-access specific tests** validating correct behavior +- **Defense-in-depth** with both UI and service layer protection + +The implementation follows best practices: +- Minimal code changes (reusable components) +- Comprehensive test coverage +- Clear documentation +- Opt-out capability for edge cases +- No breaking changes to existing functionality + +**Status:** Ready for production deployment diff --git a/lib/core/cloud/providers/geolocation/geolocation_provider.dart b/lib/core/cloud/providers/geolocation/geolocation_provider.dart index 728b8348a..f2a9e66f3 100644 --- a/lib/core/cloud/providers/geolocation/geolocation_provider.dart +++ b/lib/core/cloud/providers/geolocation/geolocation_provider.dart @@ -15,10 +15,8 @@ class GeolocationNotifier extends AsyncNotifier { @override Future build() { ref.watch(appSettingsProvider.select((state) => state.locale)); - final master = ref - .watch(deviceManagerProvider) - .nodeDevices - .firstWhereOrNull((element) => element.nodeType == 'Master'); + final nodeDevices = ref.watch(deviceManagerProvider).nodeDevices; + final master = nodeDevices.firstWhereOrNull((device) => device.isMaster); return fetch(master); } diff --git a/lib/core/data/services/session_service.dart b/lib/core/data/services/session_service.dart index 03e837af5..b72e87990 100644 --- a/lib/core/data/services/session_service.dart +++ b/lib/core/data/services/session_service.dart @@ -141,7 +141,6 @@ class SessionService { try { final result = await _routerRepository.send( JNAPAction.getDeviceInfo, - fetchRemote: true, retries: 0, timeoutMs: 3000, ); diff --git a/lib/core/jnap/router_repository.dart b/lib/core/jnap/router_repository.dart index 9a20da1fd..56a6d52da 100644 --- a/lib/core/jnap/router_repository.dart +++ b/lib/core/jnap/router_repository.dart @@ -9,6 +9,8 @@ import 'package:privacy_gui/core/data/providers/session_provider.dart'; import 'package:privacy_gui/providers/auth/_auth.dart'; import 'package:privacy_gui/providers/auth/auth_provider.dart'; import 'package:privacy_gui/providers/connectivity/_connectivity.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; +import 'package:privacy_gui/core/errors/service_error.dart'; import 'package:privacy_gui/constants/_constants.dart'; import 'package:privacy_gui/constants/jnap_const.dart'; import 'package:privacy_gui/core/bluetooth/bluetooth.dart'; @@ -70,6 +72,50 @@ class RouterRepository { bool get isEnableBTSetup => _btSetupMode; + /// Checks if the given JNAP action is a read-only operation. + /// + /// Only operations that do NOT modify router configuration are considered safe. + /// Safe operations include Get*, Is*, Check*, LED blinking, speed test, + /// and network diagnostic operations (ping, traceroute). + /// All other operations are blocked in remote read-only mode. + bool _isReadOnlyOperation(JNAPAction action) { + final actionValue = action.actionValue; + // Extract the last segment of the URL path (after the last '/') + final lastSegment = actionValue.split('/').last.toLowerCase(); + + // Allowlist of safe read-only operation prefixes + const safePrefixes = [ + 'get', // Get operations (getDeviceInfo, getWANSettings, etc.) + 'is', // Status checks (isAdminPasswordDefault, etc.) + 'check', // Validation operations (checkAdminPassword, etc.) + ]; + + // Allowlist of specific safe operations that don't modify configuration + const safeOperations = [ + 'startblinkingnodeled', // LED blinking operations + 'stopblinkingnodeled', + 'runhealthcheck', // Speed test operations (read-only, no config changes) + 'stophealthcheck', + 'startping', // Network diagnostic operations (read-only) + 'stopping', + 'starttraceroute', + 'stoptraceroute', + ]; + + return safePrefixes.any((prefix) => lastSegment.startsWith(prefix)) || + safeOperations.contains(lastSegment); + } + + /// Checks if the application is in remote read-only mode. + /// + /// Returns true when: + /// - User is logged in remotely (LoginType.remote), OR + /// - Compile-time forced remote mode (BuildConfig.forceCommandType == ForceCommand.remote) + bool _isRemoteReadOnly() { + final remoteAccess = ref.read(remoteAccessProvider); + return remoteAccess.isRemoteReadOnly; + } + Future send( JNAPAction action, { Map data = const {}, @@ -82,6 +128,13 @@ class RouterRepository { int retries = 1, SideEffectPollConfig? pollConfig, }) async { + // Defensive check: Block write operations in remote read-only mode + if (!_isReadOnlyOperation(action) && _isRemoteReadOnly()) { + throw const UnexpectedError( + message: 'Write operations are not allowed in remote read-only mode', + ); + } + cacheLevel ??= isMatchedJNAPNoCachePolicy(action) ? CacheLevel.noCache : CacheLevel.localCached; @@ -115,6 +168,17 @@ class RouterRepository { int retries = 1, SideEffectPollConfig? pollConfig, }) async { + // Defensive check: Block transactions containing write operations in remote read-only mode + if (_isRemoteReadOnly()) { + final hasWriteOperation = + builder.commands.any((entry) => !_isReadOnlyOperation(entry.key)); + if (hasWriteOperation) { + throw const UnexpectedError( + message: 'Write operations are not allowed in remote read-only mode', + ); + } + } + cacheLevel = builder.commands.any((entry) => isMatchedJNAPNoCachePolicy(entry.key)) ? CacheLevel.noCache diff --git a/lib/demo/theme_studio/theme_studio_panel.dart b/lib/demo/theme_studio/theme_studio_panel.dart index c21646e96..b8948f915 100644 --- a/lib/demo/theme_studio/theme_studio_panel.dart +++ b/lib/demo/theme_studio/theme_studio_panel.dart @@ -141,43 +141,36 @@ class _ThemeStudioPanelState extends ConsumerState { builder: (context) { return AlertDialog( title: const Text('Export Configuration'), - content: Column( - mainAxisSize: MainAxisSize.min, - children: [ - SelectableText( - jsonString, - style: TextStyle( - fontFamily: 'monospace', - fontSize: 12, - color: Theme.of(context).colorScheme.onSurface, - ), + content: SingleChildScrollView( + child: SelectableText( + jsonString, + style: TextStyle( + fontFamily: 'monospace', + fontSize: 12, + color: Theme.of(context).colorScheme.onSurface, ), - const SizedBox(height: 16), - Row( - mainAxisAlignment: MainAxisAlignment.end, - children: [ - AppButton.text( - label: 'Close', - onTap: () => Navigator.of(context).pop(), - ), - const SizedBox(width: 8), - AppButton.primary( - label: 'Copy to Clipboard', - onTap: () async { - await Clipboard.setData(ClipboardData(text: jsonString)); - if (context.mounted) { - Navigator.of(context).pop(); - ScaffoldMessenger.of(dialogContext).showSnackBar( - const SnackBar( - content: Text('Config copied to clipboard!')), - ); - } - }, - ), - ], - ), - ], + ), ), + actions: [ + AppButton.text( + label: 'Close', + onTap: () => Navigator.of(context).pop(), + ), + const SizedBox(width: 8), + AppButton.primary( + label: 'Copy to Clipboard', + onTap: () async { + await Clipboard.setData(ClipboardData(text: jsonString)); + if (context.mounted) { + Navigator.of(context).pop(); + ScaffoldMessenger.of(dialogContext).showSnackBar( + const SnackBar( + content: Text('Config copied to clipboard!')), + ); + } + }, + ), + ], ); }, ); diff --git a/lib/l10n/app_ar.arb b/lib/l10n/app_ar.arb index 281be04a8..e5b619b66 100644 --- a/lib/l10n/app_ar.arb +++ b/lib/l10n/app_ar.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "قم بزيارة دعم Linksys", "faqs": "الأسئلة الشائعة", "featureUnavailableInRemoteMode": "هذه الميزة غير متوفرة في وضع التحكم عن بُعد", + "remoteViewModeActive": "وضع العرض عن بُعد - تغييرات الإعدادات معطلة", "filterAnonymous": "تصفية طلبات إنترنت المجهولة", "filterIdent": "تصفية التعريف (المنفذ 113)", "filterInternetNATRedirection": "تصفية إعادة توجيه NAT عبر إنترنت", diff --git a/lib/l10n/app_da.arb b/lib/l10n/app_da.arb index b2985de30..38a506ae5 100644 --- a/lib/l10n/app_da.arb +++ b/lib/l10n/app_da.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Besøg Linksys Support", "faqs": "Ofte stillede spørgsmål", "featureUnavailableInRemoteMode": "Denne funktion er ikke tilgængelig i fjernbetjeningsfunktionen", + "remoteViewModeActive": "Fjernsyn tilstand - Indstillingsændringer er deaktiveret", "filterAnonymous": "Filtrer anonyme internetanmodninger", "filterIdent": "Filter-ident (port 113)", "filterInternetNATRedirection": "NAT-omdirigering af internetfilter", diff --git a/lib/l10n/app_de.arb b/lib/l10n/app_de.arb index 06c0159af..3f2292ea4 100644 --- a/lib/l10n/app_de.arb +++ b/lib/l10n/app_de.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Linksys Support besuchen", "faqs": "FAQs", "featureUnavailableInRemoteMode": "Diese Funktion ist im Fernzugriffsmodus nicht verfügbar", + "remoteViewModeActive": "Fernansichtsmodus - Einstellungsänderungen sind deaktiviert", "filterAnonymous": "Anonyme Internetanfragen filtern", "filterIdent": "Ident-Port 113 filtern", "filterInternetNATRedirection": "Internet-NAT-Umleitung filtern", diff --git a/lib/l10n/app_el.arb b/lib/l10n/app_el.arb index e35f7c4a2..23e752690 100644 --- a/lib/l10n/app_el.arb +++ b/lib/l10n/app_el.arb @@ -215,6 +215,7 @@ "faqVisitLinksysSupport": "Επισκεφθείτε την Υποστήριξη Linksys", "faqs": "Συχνές ερωτήσεις", "featureUnavailableInRemoteMode": "Αυτή η λειτουργία δεν είναι διαθέσιμη σε λειτουργία απομακρυσμένης πρόσβασης", + "remoteViewModeActive": "Λειτουργία απομακρυσμένης προβολής - Οι αλλαγές ρυθμίσεων είναι απενεργοποιημένες", "filterAnonymous": "Φιλτράρισμα ανώνυμων αιτημάτων Internet", "filterIdent": "Φιλτράρισμα ident (Θύρα 113)", "filterInternetNATRedirection": "Ανακατεύθυνση φιλτραρίσματος Internet NAT", diff --git a/lib/l10n/app_en.arb b/lib/l10n/app_en.arb index b48ea2057..8db3eb95c 100644 --- a/lib/l10n/app_en.arb +++ b/lib/l10n/app_en.arb @@ -271,6 +271,7 @@ "filteredDevices": "Filtered devices", "filters": "Filters", "featureUnavailableInRemoteMode": "This feature is unavailable in remote mode", + "remoteViewModeActive": "Remote View Mode - Setting changes are disabled", "firewall": "Firewall", "firmwareDownloadingMessage1": "You can use your WiFi during this update.", "firmwareDownloadingMessage2": "But things might be slower than usual while we improve your system.", diff --git a/lib/l10n/app_es.arb b/lib/l10n/app_es.arb index bbb1095d0..6c8fdb0f1 100644 --- a/lib/l10n/app_es.arb +++ b/lib/l10n/app_es.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Visite el Soporte Linksys", "faqs": "Preguntas Frecuentes", "featureUnavailableInRemoteMode": "Esta función no está disponible en modo remoto", + "remoteViewModeActive": "Modo de visualización remota - Los cambios de configuración están deshabilitados", "filterAnonymous": "Filtrar solicitudes anónimas de Internet", "filterIdent": "Filtrar IDENT (Puerto 113)", "filterInternetNATRedirection": "Filtrar redirección NAT de Internet", diff --git a/lib/l10n/app_es_ar.arb b/lib/l10n/app_es_ar.arb index 50704b004..b78424dc6 100644 --- a/lib/l10n/app_es_ar.arb +++ b/lib/l10n/app_es_ar.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Visite el Soporte Linksys", "faqs": "Preguntas Frecuentes", "featureUnavailableInRemoteMode": "Esta función no está disponible en modo remoto", + "remoteViewModeActive": "Modo de visualización remota - Los cambios de configuración están deshabilitados", "filterAnonymous": "Filtrar solicitudes de Internet anónimas", "filterIdent": "Filtrar identificador (Puerto 113)", "filterInternetNATRedirection": "Filtrar redirección NAT de Internet", diff --git a/lib/l10n/app_fi.arb b/lib/l10n/app_fi.arb index ea62abdce..a66a86f58 100644 --- a/lib/l10n/app_fi.arb +++ b/lib/l10n/app_fi.arb @@ -215,6 +215,7 @@ "faqVisitLinksysSupport": "Käy Linksys-tuessa", "faqs": "UKK", "featureUnavailableInRemoteMode": "Tämä ominaisuus ei ole käytettävissä etätilassa", + "remoteViewModeActive": "Etäkatselutila - Asetusten muuttaminen on poistettu käytöstä", "filterAnonymous": "Suodata anonyymit Internet-pyynnöt", "filterIdent": "Suodata ident (portti 113)", "filterInternetNATRedirection": "Suodata Internetin NAT-uudelleenohjaus", diff --git a/lib/l10n/app_fr.arb b/lib/l10n/app_fr.arb index 008b013fb..e155dd9f8 100644 --- a/lib/l10n/app_fr.arb +++ b/lib/l10n/app_fr.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Visiter le support Linksys", "faqs": "FAQ", "featureUnavailableInRemoteMode": "Cette fonctionnalité n'est pas disponible en mode distant", + "remoteViewModeActive": "Mode affichage à distance - Les modifications de paramètres sont désactivées", "filterAnonymous": "Filtrage des requêtes Internet anonymes", "filterIdent": "Filtrage IDENT (port 113)", "filterInternetNATRedirection": "Filtrage de redirection NAT Internet", diff --git a/lib/l10n/app_fr_ca.arb b/lib/l10n/app_fr_ca.arb index ffd187c7f..fb37c060b 100644 --- a/lib/l10n/app_fr_ca.arb +++ b/lib/l10n/app_fr_ca.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Visiter le support Linksys", "faqs": "FAQ", "featureUnavailableInRemoteMode": "Cette fonctionnalité n'est pas disponible en mode distant", + "remoteViewModeActive": "Mode affichage à distance - Les modifications de paramètres sont désactivées", "filterAnonymous": "Filtrage des requêtes Internet anonymes", "filterIdent": "Filtrage ident (port 113)", "filterInternetNATRedirection": "Filtrage de redirection NAT Internet", diff --git a/lib/l10n/app_id.arb b/lib/l10n/app_id.arb index 6d127303b..3a4df29ed 100644 --- a/lib/l10n/app_id.arb +++ b/lib/l10n/app_id.arb @@ -215,6 +215,7 @@ "faqVisitLinksysSupport": "Kunjungi Dukungan Linksys", "faqs": "FAQ", "featureUnavailableInRemoteMode": "Fitur ini tidak tersedia dalam mode jarak jauh", + "remoteViewModeActive": "Mode Tampilan Jarak Jauh - Perubahan pengaturan dinonaktifkan", "filterAnonymous": "Filter permintaan Internet anonim", "filterIdent": "Filter ident (Port 113)", "filterInternetNATRedirection": "Filter pengalihan NAT Internet", diff --git a/lib/l10n/app_it.arb b/lib/l10n/app_it.arb index 3e89ff6aa..93263f3e7 100644 --- a/lib/l10n/app_it.arb +++ b/lib/l10n/app_it.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Visitate il supporto Linksys", "faqs": "Domande frequenti", "featureUnavailableInRemoteMode": "Questa funzione non è disponibile in modalità remota", + "remoteViewModeActive": "Modalità visualizzazione remota - Le modifiche alle impostazioni sono disabilitate", "filterAnonymous": "Filtro richieste Internet anonime", "filterIdent": "Filtro IDENT (Porta 113)", "filterInternetNATRedirection": "Filtro reindirizzamento NAT Internet", diff --git a/lib/l10n/app_ja.arb b/lib/l10n/app_ja.arb index e6fb219dc..c9f41135f 100644 --- a/lib/l10n/app_ja.arb +++ b/lib/l10n/app_ja.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Linksysサポートへ", "faqs": "よくある質問", "featureUnavailableInRemoteMode": "この機能はリモートモードでは利用できません", + "remoteViewModeActive": "リモート表示モード - 設定変更は無効になっています", "filterAnonymous": "匿名インターネット リクエストをフィルター処理します", "filterIdent": "フィルター ID (ポート 113)", "filterInternetNATRedirection": "インターネット NAT リダイレクトをフィルター", diff --git a/lib/l10n/app_ko.arb b/lib/l10n/app_ko.arb index 52c8365f7..322afd7d2 100644 --- a/lib/l10n/app_ko.arb +++ b/lib/l10n/app_ko.arb @@ -215,6 +215,7 @@ "faqVisitLinksysSupport": "Linksys 지원 방문", "faqs": "FAQ", "featureUnavailableInRemoteMode": "이 기능은 원격 모드에서 사용할 수 없습니다", + "remoteViewModeActive": "원격 보기 모드 - 설정 변경이 비활성화되었습니다", "filterAnonymous": "익명의 인터넷 요청 필터링", "filterIdent": "ID 필터링(포트 113)", "filterInternetNATRedirection": "인터넷 NAT 리디렉션 필터링", diff --git a/lib/l10n/app_nb.arb b/lib/l10n/app_nb.arb index b0070f29f..45d735633 100644 --- a/lib/l10n/app_nb.arb +++ b/lib/l10n/app_nb.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Besøk Linksys Support", "faqs": "Vanlige spørsmål", "featureUnavailableInRemoteMode": "Denne funksjonen er ikke tilgjengelig i fjernmodus", + "remoteViewModeActive": "Ekstern visningsmodus - Innstillingsendringer er deaktivert", "filterAnonymous": "Filtrer anonyme Internett-adresser", "filterIdent": "Filter ident (Port 113)", "filterInternetNATRedirection": "Filtrer Internett-NAT-omdirigering", diff --git a/lib/l10n/app_nl.arb b/lib/l10n/app_nl.arb index fd0a51388..db45a67a9 100644 --- a/lib/l10n/app_nl.arb +++ b/lib/l10n/app_nl.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Ga naar Linksys-ondersteuning", "faqs": "Veelgestelde vragen", "featureUnavailableInRemoteMode": "Deze functie is niet beschikbaar in de externe modus", + "remoteViewModeActive": "Externe weergavemodus - Instellingswijzigingen zijn uitgeschakeld", "filterAnonymous": "Anonieme internetverzoeken filteren", "filterIdent": "IDENT filteren (poort 113)", "filterInternetNATRedirection": "Filter Doorsturen NAT", diff --git a/lib/l10n/app_pl.arb b/lib/l10n/app_pl.arb index a50062249..3ae759478 100644 --- a/lib/l10n/app_pl.arb +++ b/lib/l10n/app_pl.arb @@ -215,6 +215,7 @@ "faqVisitLinksysSupport": "Odwiedź pomoc techniczną Linksys", "faqs": "Często zadawane pytania", "featureUnavailableInRemoteMode": "Ta funkcja nie jest dostępna w trybie zdalnym", + "remoteViewModeActive": "Tryb zdalnego wyświetlania - Zmiany ustawień są wyłączone", "filterAnonymous": "Filtruj anonimowe żądania dotyczące Internetu", "filterIdent": "Filtruj protokół IDENT (port 113)", "filterInternetNATRedirection": "Filtruj przekierowania internetowe NAT", diff --git a/lib/l10n/app_pt.arb b/lib/l10n/app_pt.arb index 325f3b665..cd1163777 100644 --- a/lib/l10n/app_pt.arb +++ b/lib/l10n/app_pt.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Acesse o Suporte Linksys", "faqs": "Perguntas Frequentes", "featureUnavailableInRemoteMode": "Este recurso não está disponível no modo remoto", + "remoteViewModeActive": "Modo de visualização remota - As alterações de configuração estão desativadas", "filterAnonymous": "Filtrar solicitações de Internet anônimas", "filterIdent": "Filtrar ident (Porta 113)", "filterInternetNATRedirection": "Filtrar redirecionamento NAT da Internet", diff --git a/lib/l10n/app_pt_pt.arb b/lib/l10n/app_pt_pt.arb index a136de300..527700f0c 100644 --- a/lib/l10n/app_pt_pt.arb +++ b/lib/l10n/app_pt_pt.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Acesse o Suporte Linksys", "faqs": "Perguntas Frequentes", "featureUnavailableInRemoteMode": "Esta funcionalidade não está disponível no modo remoto", + "remoteViewModeActive": "Modo de visualização remota - As alterações de configuração estão desativadas", "filterAnonymous": "Filtrar pedidos de Internet anónimos", "filterIdent": "Filtrar ident (Porta 113)", "filterInternetNATRedirection": "Filtrar redireccionamento de NAT de Internet", diff --git a/lib/l10n/app_ru.arb b/lib/l10n/app_ru.arb index 37227fed9..f2e49d75e 100644 --- a/lib/l10n/app_ru.arb +++ b/lib/l10n/app_ru.arb @@ -215,6 +215,7 @@ "faqVisitLinksysSupport": "Посетить службу поддержки Linksys", "faqs": "Часто задаваемые вопросы", "featureUnavailableInRemoteMode": "Эта функция недоступна в удаленном режиме", + "remoteViewModeActive": "Режим удаленного просмотра - Изменение настроек отключено", "filterAnonymous": "Фильтрация анонимных интернет-запросов", "filterIdent": "Фильтрация IDENT (Порт 113)", "filterInternetNATRedirection": "Фильтрация интернет-переадресации NAT", diff --git a/lib/l10n/app_sv.arb b/lib/l10n/app_sv.arb index 7af00667c..70ada8317 100644 --- a/lib/l10n/app_sv.arb +++ b/lib/l10n/app_sv.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "Besök Linksys Support", "faqs": "Vanliga frågor", "featureUnavailableInRemoteMode": "Den här funktionen är inte tillgänglig i fjärrläge", + "remoteViewModeActive": "Fjärrvisningsläge - Inställningsändringar är inaktiverade", "filterAnonymous": "Filtrera anonyma internetbegäran", "filterIdent": "Filtrera ident (Port 113)", "filterInternetNATRedirection": "Filtrera NAT-omdirigeringar via internet", diff --git a/lib/l10n/app_th.arb b/lib/l10n/app_th.arb index 0d2e65859..fc7d9c954 100644 --- a/lib/l10n/app_th.arb +++ b/lib/l10n/app_th.arb @@ -215,6 +215,7 @@ "faqVisitLinksysSupport": "เยี่ยมชมฝ่ายสนับสนุน Linksys", "faqs": "คำถามที่พบบ่อย", "featureUnavailableInRemoteMode": "คุณลักษณะนี้ไม่พร้อมใช้งานในโหมดระยะไกล", + "remoteViewModeActive": "โหมดดูระยะไกล - การเปลี่ยนการตั้งค่าถูกปิดใช้งาน", "filterAnonymous": "กรองการร้องขออินเทอร์เน็ตที่ไม่มีชื่อ", "filterIdent": "กรอง ident (พอร์ต 113)", "filterInternetNATRedirection": "กรองการเปลี่ยนเส้นทาง NAT ของอินเทอร์เน็ต", diff --git a/lib/l10n/app_tr.arb b/lib/l10n/app_tr.arb index ae35d8e56..669a5cf89 100644 --- a/lib/l10n/app_tr.arb +++ b/lib/l10n/app_tr.arb @@ -215,6 +215,7 @@ "faqVisitLinksysSupport": "Linksys Desteği'ni ziyaret edin", "faqs": "SSS", "featureUnavailableInRemoteMode": "Bu özellik uzak modda kullanılamaz", + "remoteViewModeActive": "Uzaktan Görüntüleme Modu - Ayar değişiklikleri devre dışı", "filterAnonymous": "Anonim İnternet isteklerini engelle", "filterIdent": "Ident filtresi (Port 113)", "filterInternetNATRedirection": "İnternet NAT yeniden yönlendirmeyi engelle", diff --git a/lib/l10n/app_vi.arb b/lib/l10n/app_vi.arb index c039553db..d5f72cd8d 100644 --- a/lib/l10n/app_vi.arb +++ b/lib/l10n/app_vi.arb @@ -215,6 +215,7 @@ "faqVisitLinksysSupport": "Truy cập Hỗ trợ Linksys", "faqs": "FAQ", "featureUnavailableInRemoteMode": "Tính năng này không khả dụng trong chế độ từ xa", + "remoteViewModeActive": "Chế độ xem từ xa - Thay đổi cài đặt bị vô hiệu hóa", "filterAnonymous": "Lọc các yêu cầu Internet ẩn danh", "filterIdent": "Lọc nhận dạng (cổng 113)", "filterInternetNATRedirection": "Lọc Chuyển hướng Internet NAT", diff --git a/lib/l10n/app_zh.arb b/lib/l10n/app_zh.arb index 85ddc9298..83a7dd28e 100644 --- a/lib/l10n/app_zh.arb +++ b/lib/l10n/app_zh.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "访问Linksys支持网站", "faqs": "常见问题解答", "featureUnavailableInRemoteMode": "此功能在远程模式下不可用", + "remoteViewModeActive": "远程查看模式 - 无法修改设置", "filterAnonymous": "过滤匿名Internet请求", "filterIdent": "过滤ident协议（端口号113）", "filterInternetNATRedirection": "过滤Internet NAT重定向", diff --git a/lib/l10n/app_zh_TW.arb b/lib/l10n/app_zh_TW.arb index 7e7ca812b..a8272743d 100644 --- a/lib/l10n/app_zh_TW.arb +++ b/lib/l10n/app_zh_TW.arb @@ -233,6 +233,7 @@ "faqVisitLinksysSupport": "瀏覽Linksys支援網站", "faqs": "常見問題解答", "featureUnavailableInRemoteMode": "此功能在遠端模式下無法使用", + "remoteViewModeActive": "遠端檢視模式 - 無法修改設定", "filterAnonymous": "篩選匿名網際網路請求", "filterIdent": "篩選器身份（連接埠 113）", "filterInternetNATRedirection": "篩選網際網路 NAT 重新導向", diff --git a/lib/page/advanced_settings/internet_settings/views/ipv4_connection_view.dart b/lib/page/advanced_settings/internet_settings/views/ipv4_connection_view.dart index 3cdac6a28..ea2d1abe5 100644 --- a/lib/page/advanced_settings/internet_settings/views/ipv4_connection_view.dart +++ b/lib/page/advanced_settings/internet_settings/views/ipv4_connection_view.dart @@ -1,14 +1,15 @@ import 'package:flutter/material.dart'; -import 'package:privacy_gui/constants/build_config.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; import 'package:privacy_gui/core/utils/extension.dart'; import 'package:privacy_gui/localization/localization_hook.dart'; import 'package:privacy_gui/page/advanced_settings/internet_settings/providers/internet_settings_provider.dart'; import 'package:privacy_gui/page/advanced_settings/internet_settings/providers/internet_settings_state.dart'; import 'package:privacy_gui/page/advanced_settings/internet_settings/widgets/optional_settings_form.dart'; import 'package:privacy_gui/page/advanced_settings/internet_settings/widgets/wan_forms/wan_form_factory.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; import 'package:ui_kit_library/ui_kit.dart'; -class Ipv4ConnectionView extends StatelessWidget { +class Ipv4ConnectionView extends ConsumerWidget { final bool isEditing; final bool isBridgeMode; final InternetSettingsState internetSettingsState; @@ -25,7 +26,7 @@ class Ipv4ConnectionView extends StatelessWidget { }) : super(key: key); @override - Widget build(BuildContext context) { + Widget build(BuildContext context, WidgetRef ref) { return SingleChildScrollView( child: Padding( padding: EdgeInsets.symmetric( @@ -35,7 +36,7 @@ class Ipv4ConnectionView extends StatelessWidget { crossAxisAlignment: CrossAxisAlignment.start, mainAxisSize: MainAxisSize.min, children: [ - _infoCard(context), + _infoCard(context, ref), AppGap.xl(), OptionalSettingsForm( isEditing: isEditing, @@ -48,7 +49,7 @@ class Ipv4ConnectionView extends StatelessWidget { mainAxisSize: MainAxisSize.min, children: [ Expanded( - child: _infoCard(context), + child: _infoCard(context, ref), ), AppGap.gutter(), Expanded( @@ -63,7 +64,7 @@ class Ipv4ConnectionView extends StatelessWidget { ); } - Widget _infoCard(BuildContext context) { + Widget _infoCard(BuildContext context, WidgetRef ref) { final infoCards = _buildInfoCards(context); return AppCard( padding: const EdgeInsets.symmetric( @@ -83,7 +84,7 @@ class Ipv4ConnectionView extends StatelessWidget { AppText.titleMedium( loc(context).internetConnectionType.capitalizeWords()), const Spacer(), - _editButton(context), + _editButton(context, ref), ], ), ), @@ -93,16 +94,19 @@ class Ipv4ConnectionView extends StatelessWidget { ); } - Widget _editButton(BuildContext context) { - final isRemote = BuildConfig.isRemote(); + Widget _editButton(BuildContext context, WidgetRef ref) { + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); return Tooltip( - message: isRemote ? loc(context).featureUnavailableInRemoteMode : '', + message: + isRemoteReadOnly ? loc(context).featureUnavailableInRemoteMode : '', child: AppIconButton( key: const Key('ipv4EditButton'), icon: Icon( isEditing ? AppFontIcons.close : AppFontIcons.edit, ), - onTap: isRemote ? null : onEditToggle, + onTap: isRemoteReadOnly ? null : onEditToggle, )); } diff --git a/lib/page/advanced_settings/internet_settings/views/ipv6_connection_view.dart b/lib/page/advanced_settings/internet_settings/views/ipv6_connection_view.dart index 98da8a328..b2eb209cf 100644 --- a/lib/page/advanced_settings/internet_settings/views/ipv6_connection_view.dart +++ b/lib/page/advanced_settings/internet_settings/views/ipv6_connection_view.dart @@ -1,14 +1,15 @@ import 'package:flutter/material.dart'; -import 'package:privacy_gui/constants/build_config.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; import 'package:privacy_gui/core/utils/extension.dart'; import 'package:privacy_gui/localization/localization_hook.dart'; import 'package:privacy_gui/page/advanced_settings/internet_settings/providers/internet_settings_provider.dart'; import 'package:privacy_gui/page/advanced_settings/internet_settings/providers/internet_settings_state.dart'; import 'package:privacy_gui/page/advanced_settings/internet_settings/widgets/optional_settings_form.dart'; import 'package:privacy_gui/page/advanced_settings/internet_settings/widgets/wan_forms/ipv6/ipv6_wan_form_factory.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; import 'package:ui_kit_library/ui_kit.dart'; -class Ipv6ConnectionView extends StatelessWidget { +class Ipv6ConnectionView extends ConsumerWidget { final bool isEditing; final bool isBridgeMode; final InternetSettingsState internetSettingsState; @@ -25,7 +26,7 @@ class Ipv6ConnectionView extends StatelessWidget { }) : super(key: key); @override - Widget build(BuildContext context) { + Widget build(BuildContext context, WidgetRef ref) { return SingleChildScrollView( child: Padding( padding: EdgeInsets.symmetric( @@ -35,7 +36,7 @@ class Ipv6ConnectionView extends StatelessWidget { crossAxisAlignment: CrossAxisAlignment.start, mainAxisSize: MainAxisSize.min, children: [ - _infoCard(context), + _infoCard(context, ref), AppGap.xl(), OptionalSettingsForm( isEditing: isEditing, @@ -48,7 +49,7 @@ class Ipv6ConnectionView extends StatelessWidget { mainAxisSize: MainAxisSize.min, children: [ Expanded( - child: _infoCard(context), + child: _infoCard(context, ref), ), AppGap.gutter(), Expanded( @@ -63,7 +64,7 @@ class Ipv6ConnectionView extends StatelessWidget { ); } - Widget _infoCard(BuildContext context) { + Widget _infoCard(BuildContext context, WidgetRef ref) { final infoCards = _buildInfoCards(context); return AppCard( padding: const EdgeInsets.symmetric( @@ -83,7 +84,7 @@ class Ipv6ConnectionView extends StatelessWidget { AppText.titleMedium( loc(context).internetConnectionType.capitalizeWords()), const Spacer(), - _editButton(context), + _editButton(context, ref), ], ), ), @@ -93,16 +94,19 @@ class Ipv6ConnectionView extends StatelessWidget { ); } - Widget _editButton(BuildContext context) { - final isRemote = BuildConfig.isRemote(); + Widget _editButton(BuildContext context, WidgetRef ref) { + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); return Tooltip( - message: isRemote ? loc(context).featureUnavailableInRemoteMode : '', + message: + isRemoteReadOnly ? loc(context).featureUnavailableInRemoteMode : '', child: AppIconButton( key: const Key('ipv6EditButton'), icon: Icon( isEditing ? AppFontIcons.close : AppFontIcons.edit, ), - onTap: isRemote ? null : onEditToggle, + onTap: isRemoteReadOnly ? null : onEditToggle, )); } diff --git a/lib/page/advanced_settings/internet_settings/views/release_and_renew_view.dart b/lib/page/advanced_settings/internet_settings/views/release_and_renew_view.dart index c1d9e24a3..be0a7345a 100644 --- a/lib/page/advanced_settings/internet_settings/views/release_and_renew_view.dart +++ b/lib/page/advanced_settings/internet_settings/views/release_and_renew_view.dart @@ -13,6 +13,7 @@ import 'package:privacy_gui/page/advanced_settings/internet_settings/providers/i import 'package:privacy_gui/page/advanced_settings/internet_settings/views/internet_settings_view.dart'; import 'package:privacy_gui/page/components/shortcuts/dialogs.dart'; import 'package:privacy_gui/page/components/shortcuts/snack_bar.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; import 'package:privacy_gui/util/error_code_helper.dart'; import 'package:ui_kit_library/ui_kit.dart'; @@ -34,6 +35,9 @@ class ReleaseAndRenewView extends ConsumerWidget { ref.watch(deviceManagerProvider.select((state) => state.wanStatus)); final wanIpv6Type = WanIPv6Type.resolve( internetSettingsState.settings.current.ipv6Setting.ipv6ConnectionType); + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); return SingleChildScrollView( child: Padding( @@ -64,7 +68,7 @@ class ReleaseAndRenewView extends ConsumerWidget { AppButton.text( key: const ValueKey('ipv4ReleaseRenewButton'), label: loc(context).releaseAndRenew, - onTap: isBridgeMode + onTap: isBridgeMode || isRemoteReadOnly ? null : () { _showRenewIPAlert( @@ -97,7 +101,8 @@ class ReleaseAndRenewView extends ConsumerWidget { key: const ValueKey('ipv6ReleaseRenewButton'), label: loc(context).releaseAndRenew, onTap: isBridgeMode || - wanIpv6Type == WanIPv6Type.passThrough + wanIpv6Type == WanIPv6Type.passThrough || + isRemoteReadOnly ? null : () { _showRenewIPAlert( diff --git a/lib/page/advanced_settings/local_network_settings/views/local_network_settings_view.dart b/lib/page/advanced_settings/local_network_settings/views/local_network_settings_view.dart index a0bf11629..181989e11 100644 --- a/lib/page/advanced_settings/local_network_settings/views/local_network_settings_view.dart +++ b/lib/page/advanced_settings/local_network_settings/views/local_network_settings_view.dart @@ -2,7 +2,6 @@ import 'dart:async'; import 'package:flutter/foundation.dart'; import 'package:flutter/material.dart'; import 'package:flutter_riverpod/flutter_riverpod.dart'; -import 'package:privacy_gui/constants/build_config.dart'; import 'package:privacy_gui/core/errors/service_error.dart'; import 'package:privacy_gui/core/utils/extension.dart'; import 'package:privacy_gui/core/utils/ip_getter/ip_getter.dart'; @@ -17,6 +16,7 @@ import 'package:privacy_gui/page/advanced_settings/local_network_settings/provid import 'package:privacy_gui/page/advanced_settings/local_network_settings/providers/local_network_settings_state.dart'; import 'package:privacy_gui/page/instant_safety/providers/instant_safety_provider.dart'; import 'package:privacy_gui/providers/redirection/redirection_provider.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; import 'package:ui_kit_library/ui_kit.dart'; import 'package:privacy_gui/core/utils/assign_ip/assign_ip.dart'; @@ -73,7 +73,10 @@ class _LocalNetworkSettingsViewState @override Widget build(BuildContext context) { - if (!BuildConfig.isRemote()) { + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); + if (!isRemoteReadOnly) { ref.listen(redirectionProvider, (previous, next) { if (kIsWeb && next != null && @@ -312,8 +315,8 @@ class _LocalNetworkSettingsViewState return; } // ip case - if (state.settings.current.ipAddress != currentUrl && - !BuildConfig.isRemote()) { + final isRemoteReadOnly = ref.read(remoteAccessProvider).isRemoteReadOnly; + if (state.settings.current.ipAddress != currentUrl && !isRemoteReadOnly) { _doRedirect(state.settings.current.ipAddress); } } diff --git a/lib/page/components/layouts/root_container.dart b/lib/page/components/layouts/root_container.dart index 00414bb79..4f0d92148 100644 --- a/lib/page/components/layouts/root_container.dart +++ b/lib/page/components/layouts/root_container.dart @@ -4,6 +4,7 @@ import 'package:flutter/foundation.dart'; import 'package:flutter/material.dart'; import 'package:flutter_riverpod/flutter_riverpod.dart'; import 'package:privacy_gui/page/components/layouts/idle_checker.dart'; +import 'package:privacy_gui/page/components/views/remote_read_only_banner.dart'; import 'package:privacy_gui/providers/auth/_auth.dart'; import 'package:privacy_gui/providers/idle_checker_pause_provider.dart'; @@ -68,11 +69,24 @@ class _AppRootContainerState extends ConsumerState { color: Theme.of(context).colorScheme.surface, child: CompositedTransformTarget( link: _link, - child: Stack( + child: Column( children: [ - _buildLayout(Container(child: widget.child ?? const Center()), - constraints), - ..._handleConnectivity(ref), + // Remote read-only banner at the top (respects safe area) + const SafeArea( + bottom: false, + child: RemoteReadOnlyBanner(), + ), + // Main content with connectivity overlay + Expanded( + child: Stack( + children: [ + _buildLayout( + Container(child: widget.child ?? const Center()), + constraints), + ..._handleConnectivity(ref), + ], + ), + ), ], ), ), diff --git a/lib/page/components/ui_kit_page_view.dart b/lib/page/components/ui_kit_page_view.dart index 7fba2b06c..7c1f4d58e 100644 --- a/lib/page/components/ui_kit_page_view.dart +++ b/lib/page/components/ui_kit_page_view.dart @@ -3,6 +3,7 @@ import 'package:flutter_riverpod/flutter_riverpod.dart'; import 'package:go_router/go_router.dart'; import 'package:privacy_gui/localization/localization_hook.dart'; import 'package:privacy_gui/page/components/styled/top_bar.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; import 'package:ui_kit_library/ui_kit.dart'; const double kDefaultToolbarHeight = kToolbarHeight; // 56 @@ -37,6 +38,7 @@ class UiKitBottomBarConfig { final bool isPositiveEnabled; final bool isNegativeEnabled; final bool isDestructive; + final bool checkRemoteReadOnly; const UiKitBottomBarConfig({ this.positiveLabel, @@ -46,6 +48,7 @@ class UiKitBottomBarConfig { this.isPositiveEnabled = true, this.isNegativeEnabled = true, this.isDestructive = false, + this.checkRemoteReadOnly = true, }); } @@ -487,6 +490,12 @@ class _UiKitPageViewState extends ConsumerState { final bottomBar = widget.bottomBar!; + // Check remote read-only mode + final isRemoteReadOnly = bottomBar.checkRemoteReadOnly + ? ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly)) + : false; + // T078: Native PrivacyGUI localization support // Note: PrivacyGUI localization will be added when needed @@ -501,7 +510,7 @@ class _UiKitPageViewState extends ConsumerState { context.pop(); // Default back navigation } }, - isPositiveEnabled: bottomBar.isPositiveEnabled, + isPositiveEnabled: bottomBar.isPositiveEnabled && !isRemoteReadOnly, isNegativeEnabled: bottomBar.isNegativeEnabled, isDestructive: bottomBar.isDestructive, ); diff --git a/lib/page/components/views/remote_aware_switch.dart b/lib/page/components/views/remote_aware_switch.dart new file mode 100644 index 000000000..7cbffd5c8 --- /dev/null +++ b/lib/page/components/views/remote_aware_switch.dart @@ -0,0 +1,39 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; +import 'package:ui_kit_library/ui_kit.dart'; + +/// A switch widget that automatically disables in remote read-only mode. +/// +/// This widget wraps AppSwitch and monitors the remote access state. +/// When the application is in remote read-only mode (user logged in remotely +/// or forced remote mode), the switch's onChanged callback is set to null, +/// effectively disabling user interaction. +/// +/// Use this for switches that directly trigger JNAP SET operations. +/// For switches that only modify local UI state, use regular AppSwitch. +class RemoteAwareSwitch extends ConsumerWidget { + const RemoteAwareSwitch({ + super.key, + required this.value, + required this.onChanged, + }); + + /// The current value of the switch + final bool value; + + /// Callback when switch is toggled (disabled in remote mode) + final ValueChanged? onChanged; + + @override + Widget build(BuildContext context, WidgetRef ref) { + final isReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); + + return AppSwitch( + value: value, + onChanged: isReadOnly ? null : onChanged, + ); + } +} diff --git a/lib/page/components/views/remote_read_only_banner.dart b/lib/page/components/views/remote_read_only_banner.dart new file mode 100644 index 000000000..bc88cdc32 --- /dev/null +++ b/lib/page/components/views/remote_read_only_banner.dart @@ -0,0 +1,59 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:privacy_gui/localization/localization_hook.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; + +/// A banner widget that displays when the application is in remote read-only mode. +/// +/// This banner appears at the top of the application to inform users that +/// router configuration changes are disabled when accessing remotely. +class RemoteReadOnlyBanner extends ConsumerWidget { + const RemoteReadOnlyBanner({super.key}); + + @override + Widget build(BuildContext context, WidgetRef ref) { + final isReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); + + if (!isReadOnly) { + return const SizedBox.shrink(); + } + + final colorScheme = Theme.of(context).colorScheme; + final textTheme = Theme.of(context).textTheme; + + return Container( + width: double.infinity, + padding: const EdgeInsets.symmetric(vertical: 12, horizontal: 16), + decoration: BoxDecoration( + color: colorScheme.errorContainer, + border: Border( + bottom: BorderSide( + color: colorScheme.error.withValues(alpha: 0.3), + width: 2, + ), + ), + ), + child: Row( + children: [ + Icon( + Icons.info_outline, + color: colorScheme.onErrorContainer, + size: 24, + ), + const SizedBox(width: 12), + Expanded( + child: Text( + loc(context).remoteViewModeActive, + style: textTheme.bodyLarge?.copyWith( + color: colorScheme.onErrorContainer, + fontWeight: FontWeight.w600, + ), + ), + ), + ], + ), + ); + } +} diff --git a/lib/page/dashboard/views/components/widgets/composite/port_and_speed.dart b/lib/page/dashboard/views/components/widgets/composite/port_and_speed.dart index 70fb518db..f52c40c48 100644 --- a/lib/page/dashboard/views/components/widgets/composite/port_and_speed.dart +++ b/lib/page/dashboard/views/components/widgets/composite/port_and_speed.dart @@ -1,7 +1,6 @@ import 'package:collection/collection.dart'; import 'package:flutter/material.dart'; import 'package:flutter_riverpod/flutter_riverpod.dart'; -import 'package:privacy_gui/constants/build_config.dart'; import 'package:privacy_gui/localization/localization_hook.dart'; import 'package:privacy_gui/page/dashboard/models/display_mode.dart'; import 'package:privacy_gui/page/dashboard/providers/dashboard_home_provider.dart'; @@ -13,6 +12,7 @@ import 'package:privacy_gui/page/dashboard/views/components/widgets/parts/intern import 'package:privacy_gui/page/dashboard/views/components/widgets/parts/port_status_widget.dart'; import 'package:privacy_gui/page/health_check/providers/health_check_provider.dart'; import 'package:privacy_gui/page/health_check/widgets/speed_test_widget.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; import 'package:ui_kit_library/ui_kit.dart'; /// Dashboard widget showing port connections and speed test results. @@ -334,7 +334,9 @@ class DashboardHomePortAndSpeed extends ConsumerWidget { DashboardHomeState state, bool hasLanPort, ) { - final isRemote = BuildConfig.isRemote(); + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); final isHealthCheckSupported = ref.watch(healthCheckProvider).isSpeedTestModuleSupported; @@ -359,9 +361,9 @@ class DashboardHomePortAndSpeed extends ConsumerWidget { return Tooltip( message: loc(context).featureUnavailableInRemoteMode, child: Opacity( - opacity: isRemote ? 0.5 : 1, + opacity: isRemoteReadOnly ? 0.5 : 1, child: AbsorbPointer( - absorbing: isRemote, + absorbing: isRemoteReadOnly, child: ExternalSpeedTestLinks(state: state), ), ), diff --git a/lib/page/dashboard/views/components/widgets/composite/quick_panel.dart b/lib/page/dashboard/views/components/widgets/composite/quick_panel.dart index 29a31b62a..f7e3e948d 100644 --- a/lib/page/dashboard/views/components/widgets/composite/quick_panel.dart +++ b/lib/page/dashboard/views/components/widgets/composite/quick_panel.dart @@ -7,6 +7,7 @@ import 'package:privacy_gui/page/nodes/providers/node_light_settings_provider.da import 'package:privacy_gui/core/utils/nodes.dart'; import 'package:privacy_gui/localization/localization_hook.dart'; import 'package:privacy_gui/page/components/shortcuts/dialogs.dart'; +import 'package:privacy_gui/page/components/views/remote_aware_switch.dart'; import 'package:privacy_gui/page/dashboard/models/display_mode.dart'; import 'package:privacy_gui/page/dashboard/views/components/core/dashboard_loading_wrapper.dart'; import 'package:privacy_gui/page/instant_privacy/providers/instant_privacy_device_list_provider.dart'; @@ -172,7 +173,7 @@ class _DashboardQuickPanelState extends ConsumerState { width: 48, height: 28, child: FittedBox( - child: AppSwitch( + child: RemoteAwareSwitch( value: isActive, onChanged: onToggle, ), @@ -385,7 +386,7 @@ class _DashboardQuickPanelState extends ConsumerState { ), ), AppGap.lg(), - AppSwitch(value: value, onChanged: onChanged), + RemoteAwareSwitch(value: value, onChanged: onChanged), ], ), ); @@ -443,7 +444,7 @@ class _DashboardQuickPanelState extends ConsumerState { ], ), ), - AppSwitch( + RemoteAwareSwitch( key: ValueKey(semantics), value: value, onChanged: onChanged, diff --git a/lib/page/dashboard/views/components/widgets/parts/wifi_card.dart b/lib/page/dashboard/views/components/widgets/parts/wifi_card.dart index 0e5d745e2..4ff772c89 100644 --- a/lib/page/dashboard/views/components/widgets/parts/wifi_card.dart +++ b/lib/page/dashboard/views/components/widgets/parts/wifi_card.dart @@ -5,6 +5,7 @@ import 'package:go_router/go_router.dart'; import 'package:privacy_gui/core/errors/service_error.dart'; import 'package:privacy_gui/localization/localization_hook.dart'; import 'package:privacy_gui/page/components/shortcuts/dialogs.dart'; +import 'package:privacy_gui/page/components/views/remote_aware_switch.dart'; import 'package:privacy_gui/page/dashboard/providers/dashboard_home_provider.dart'; import 'package:privacy_gui/page/dashboard/providers/dashboard_home_state.dart'; import 'package:privacy_gui/page/wifi_settings/_wifi_settings.dart'; @@ -143,7 +144,7 @@ class _WiFiCardState extends ConsumerState { .join('/')), ), ), - AppSwitch( + RemoteAwareSwitch( value: widget.item.isEnabled, onChanged: widget.item.isGuest || !widget.item.isEnabled || diff --git a/lib/page/instant_admin/views/instant_admin_view.dart b/lib/page/instant_admin/views/instant_admin_view.dart index dfad0c655..e0d3fe948 100644 --- a/lib/page/instant_admin/views/instant_admin_view.dart +++ b/lib/page/instant_admin/views/instant_admin_view.dart @@ -3,7 +3,6 @@ import 'package:flutter/material.dart'; import 'package:flutter_riverpod/flutter_riverpod.dart'; import 'package:flutter_staggered_grid_view/flutter_staggered_grid_view.dart'; import 'package:go_router/go_router.dart'; -import 'package:privacy_gui/constants/build_config.dart'; import 'package:privacy_gui/core/data/providers/device_info_provider.dart'; import 'package:privacy_gui/core/data/providers/firmware_update_provider.dart'; import 'package:privacy_gui/core/errors/service_error.dart'; @@ -12,8 +11,10 @@ import 'package:privacy_gui/page/components/shortcuts/dialogs.dart'; import 'package:privacy_gui/page/components/shortcuts/snack_bar.dart'; import 'package:privacy_gui/page/components/ui_kit_page_view.dart'; import 'package:privacy_gui/page/components/views/arguments_view.dart'; +import 'package:privacy_gui/page/components/views/remote_aware_switch.dart'; import 'package:privacy_gui/core/utils/logger.dart'; import 'package:privacy_gui/page/instant_admin/providers/_providers.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; import 'package:privacy_gui/route/constants.dart'; import 'package:privacy_gui/util/timezone.dart'; import 'package:privacy_gui/validator_rules/_validator_rules.dart'; @@ -100,6 +101,10 @@ class _InstantAdminViewState extends ConsumerState { BuildContext context, RouterPasswordState routerPasswordState, ) { + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); + return AppCard( padding: EdgeInsets.symmetric( vertical: AppSpacing.lg, @@ -107,16 +112,23 @@ class _InstantAdminViewState extends ConsumerState { ), child: Column( children: [ - _buildListRow( - key: const Key('passwordCard'), - title: loc(context).routerPassword, - description: AppText.labelLarge( - '•' * (routerPasswordState.adminPassword.length.clamp(0, 16)), + Tooltip( + message: isRemoteReadOnly + ? loc(context).featureUnavailableInRemoteMode + : '', + child: _buildListRow( + key: const Key('passwordCard'), + title: loc(context).routerPassword, + description: AppText.labelLarge( + '•' * (routerPasswordState.adminPassword.length.clamp(0, 16)), + ), + trailing: AppIcon.font(AppFontIcons.edit), + onTap: isRemoteReadOnly + ? null + : () { + _showRouterPasswordModal(routerPasswordState.hint); + }, ), - trailing: AppIcon.font(AppFontIcons.edit), - onTap: () { - _showRouterPasswordModal(routerPasswordState.hint); - }, ), const Divider(), _buildListRow( @@ -160,17 +172,19 @@ class _InstantAdminViewState extends ConsumerState { DeviceInfoState deviceInfoState, ) { final firmwareVersion = deviceInfoState.deviceInfo?.firmwareVersion; + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); return _buildListCard( title: loc(context).manualFirmwareUpdate, description: firmwareVersion ?? '--', trailing: Tooltip( - message: BuildConfig.isRemote() - ? loc(context).featureUnavailableInRemoteMode - : '', + message: + isRemoteReadOnly ? loc(context).featureUnavailableInRemoteMode : '', child: AppButton.text( label: loc(context).manualUpdate, key: const Key('manualUpdateButton'), - onTap: BuildConfig.isRemote() + onTap: isRemoteReadOnly ? null : () { context.goNamed(RouteNamed.manualFirmwareUpdate); @@ -306,7 +320,7 @@ class _InstantAdminViewState extends ConsumerState { return Row( children: [ Expanded(child: AppText.labelLarge(title)), - AppSwitch( + RemoteAwareSwitch( value: value, onChanged: (newValue) async { await onChanged(newValue); diff --git a/lib/page/instant_device/views/device_detail_view.dart b/lib/page/instant_device/views/device_detail_view.dart index d74e8c2fc..be63eaa47 100644 --- a/lib/page/instant_device/views/device_detail_view.dart +++ b/lib/page/instant_device/views/device_detail_view.dart @@ -22,6 +22,7 @@ import 'package:privacy_gui/localization/localization_hook.dart'; import 'package:privacy_gui/page/dashboard/_dashboard.dart'; import 'package:privacy_gui/page/instant_device/_instant_device.dart'; import 'package:privacy_gui/page/instant_device/extensions/icon_device_category_ext.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; import 'package:privacy_gui/utils.dart'; import 'package:privacy_gui/validator_rules/rules.dart'; import 'package:privacy_gui/page/components/composed/app_loadable_widget.dart'; @@ -117,6 +118,9 @@ class _DeviceDetailViewState extends ConsumerState { } Widget _avatarCard(BuildContext context, ExternalDeviceDetailState state) { + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); return SelectionArea( child: AppCard( padding: EdgeInsets.all(AppSpacing.sm), @@ -135,9 +139,14 @@ class _DeviceDetailViewState extends ConsumerState { _buildSettingRow( context, title: state.item.name, - trailing: AppIconButton( - icon: AppIcon.font(AppFontIcons.edit), - onTap: _showEdidDeviceModal, + trailing: Tooltip( + message: isRemoteReadOnly + ? loc(context).featureUnavailableInRemoteMode + : '', + child: AppIconButton( + icon: AppIcon.font(AppFontIcons.edit), + onTap: isRemoteReadOnly ? null : _showEdidDeviceModal, + ), ), ), _buildSettingRow( @@ -335,11 +344,15 @@ class _DeviceDetailViewState extends ConsumerState { Widget _buildIpAddressCard( BuildContext context, ExternalDeviceDetailState state, bool isBridge) { + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); final showReserveButton = !isBridge && state.item.isOnline && state.item.ipv4Address.isNotEmpty && state.item.type != WifiConnectionType.guest && - isReservedIp != null; + isReservedIp != null && + !isRemoteReadOnly; return AppCard( padding: EdgeInsets.symmetric( diff --git a/lib/page/instant_privacy/views/instant_privacy_view.dart b/lib/page/instant_privacy/views/instant_privacy_view.dart index c7fa90454..8b74e11f8 100644 --- a/lib/page/instant_privacy/views/instant_privacy_view.dart +++ b/lib/page/instant_privacy/views/instant_privacy_view.dart @@ -8,6 +8,7 @@ import 'package:privacy_gui/page/components/shared_widgets.dart'; import 'package:privacy_gui/page/components/shortcuts/dialogs.dart'; import 'package:privacy_gui/page/components/ui_kit_page_view.dart'; import 'package:privacy_gui/page/components/views/arguments_view.dart'; +import 'package:privacy_gui/page/components/views/remote_aware_switch.dart'; import 'package:privacy_gui/page/instant_device/extensions/icon_device_category_ext.dart'; import 'package:privacy_gui/page/instant_device/providers/device_list_state.dart'; import 'package:privacy_gui/page/instant_privacy/providers/instant_privacy_device_list_provider.dart'; @@ -310,7 +311,7 @@ class _InstantPrivacyViewState extends ConsumerState child: Row( children: [ Expanded(child: AppText.labelLarge(loc(context).instantPrivacy)), - AppSwitch( + RemoteAwareSwitch( value: state.settings.current.mode == MacFilterMode.allow, onChanged: (value) { _showEnableDialog(value); diff --git a/lib/page/instant_topology/helpers/topology_menu_helper.dart b/lib/page/instant_topology/helpers/topology_menu_helper.dart index d900359d6..b0944a8be 100644 --- a/lib/page/instant_topology/helpers/topology_menu_helper.dart +++ b/lib/page/instant_topology/helpers/topology_menu_helper.dart @@ -5,6 +5,7 @@ import 'package:privacy_gui/core/utils/topology_adapter.dart'; import 'package:privacy_gui/localization/localization_hook.dart'; import 'package:privacy_gui/page/instant_topology/views/model/node_instant_actions.dart'; import 'package:privacy_gui/page/instant_topology/views/model/topology_model.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; import 'package:ui_kit_library/ui_kit.dart'; /// Helper class for building and handling topology node menu items. @@ -20,8 +21,10 @@ class TopologyMenuHelper { /// /// Returns null for Internet nodes or empty menu. /// Menu items are based on node type and device capabilities. + /// In remote read-only mode, only Details and Blink Device Light are enabled. List>? buildNodeMenu( BuildContext context, + WidgetRef ref, MeshNode meshNode, ) { // Don't show menu for internet nodes @@ -29,6 +32,9 @@ class TopologyMenuHelper { final items = >[]; final isOffline = meshNode.status == MeshNodeStatus.offline; + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); // Always add details for all online node types if (!meshNode.isOffline) { @@ -50,48 +56,53 @@ class TopologyMenuHelper { // Extender and Gateway menu items if (meshNode.isExtender || meshNode.isGateway) { - // Reboot action + // Reboot action (disabled in remote mode) if (supportChildReboot) { items.add(AppPopupMenuItem( value: 'reboot', label: loc(context).rebootUnit, icon: Icons.restart_alt, + enabled: !isRemoteReadOnly, )); } - // Blink device light + // Blink device light (always enabled, even in remote mode) items.add(AppPopupMenuItem( value: 'blink', label: loc(context).blinkDeviceLight, icon: Icons.lightbulb_outline, )); - // Pairing options for gateway + // Pairing options for gateway (disabled in remote mode) if (meshNode.isGateway && autoOnboarding) { items.add(AppPopupMenuItem( value: 'pair', label: loc(context).instantPair, icon: Icons.link, + enabled: !isRemoteReadOnly, children: [ AppPopupMenuItem( value: 'pairWired', label: loc(context).pairWiredNode, icon: Icons.cable, + enabled: !isRemoteReadOnly, ), AppPopupMenuItem( value: 'pairWireless', label: loc(context).pairWirelessNode, icon: Icons.wifi, + enabled: !isRemoteReadOnly, ), ], )); } - // Factory reset for extenders and gateway + // Factory reset for extenders and gateway (disabled in remote mode) items.add(AppPopupMenuItem( value: 'reset', label: loc(context).resetToFactoryDefault, icon: Icons.restore, + enabled: !isRemoteReadOnly, )); } diff --git a/lib/page/instant_topology/views/instant_topology_view.dart b/lib/page/instant_topology/views/instant_topology_view.dart index dde64c083..a59c1e05f 100644 --- a/lib/page/instant_topology/views/instant_topology_view.dart +++ b/lib/page/instant_topology/views/instant_topology_view.dart @@ -127,7 +127,8 @@ class _InstantTopologyViewState extends ConsumerState { onNodeTap(context, ref, originalNode); } }, - nodeMenuBuilder: _menuHelper.buildNodeMenu, + nodeMenuBuilder: (context, meshNode) => + _menuHelper.buildNodeMenu(context, ref, meshNode), onNodeMenuSelected: (nodeId, action) => _handleNodeMenuAction( context, ref, diff --git a/lib/page/instant_verify/views/instant_verify_view.dart b/lib/page/instant_verify/views/instant_verify_view.dart index 70f8e29f7..e11da57f7 100644 --- a/lib/page/instant_verify/views/instant_verify_view.dart +++ b/lib/page/instant_verify/views/instant_verify_view.dart @@ -2,7 +2,6 @@ import 'package:collection/collection.dart'; import 'package:flutter_riverpod/flutter_riverpod.dart'; import 'package:go_router/go_router.dart'; -import 'package:privacy_gui/constants/build_config.dart'; import 'package:privacy_gui/core/data/providers/device_info_provider.dart'; import 'package:privacy_gui/core/data/providers/router_time_provider.dart'; import 'package:privacy_gui/core/data/providers/system_stats_provider.dart'; @@ -34,6 +33,7 @@ import 'package:privacy_gui/page/instant_topology/helpers/topology_menu_helper.d import 'package:privacy_gui/page/instant_topology/views/model/node_instant_actions.dart'; import 'package:privacy_gui/page/instant_topology/views/widgets/instant_topology_card.dart'; import 'package:privacy_gui/page/nodes/providers/node_detail_id_provider.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; import 'package:privacy_gui/utils.dart'; import 'package:privacy_gui/route/constants.dart'; @@ -137,7 +137,8 @@ class _InstantVerifyViewState extends ConsumerState context.pushNamed(RouteNamed.nodeDetails); } }, - nodeMenuBuilder: _menuHelper.buildNodeMenu, + nodeMenuBuilder: (context, meshNode) => + _menuHelper.buildNodeMenu(context, ref, meshNode), nodeBuilder: (context, meshNode, isOffline) { // Special handling for Internet node if (meshNode.type == MeshNodeType.internet) { @@ -1018,6 +1019,9 @@ class _InstantVerifyViewState extends ConsumerState Widget _speedTestContent(BuildContext context) { final isHealthCheckSupported = ref.watch(healthCheckProvider).isSpeedTestModuleSupported; + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); return AppCard( key: const ValueKey('speedTestCard'), padding: EdgeInsets.all(AppSpacing.xxl), @@ -1031,9 +1035,9 @@ class _InstantVerifyViewState extends ConsumerState child: Tooltip( message: loc(context).featureUnavailableInRemoteMode, child: Opacity( - opacity: BuildConfig.isRemote() ? 0.5 : 1, + opacity: isRemoteReadOnly ? 0.5 : 1, child: AbsorbPointer( - absorbing: BuildConfig.isRemote(), + absorbing: isRemoteReadOnly, child: const SpeedTestExternalWidget(), ), ), diff --git a/lib/page/nodes/views/node_detail_view.dart b/lib/page/nodes/views/node_detail_view.dart index cc591389f..04651dd75 100644 --- a/lib/page/nodes/views/node_detail_view.dart +++ b/lib/page/nodes/views/node_detail_view.dart @@ -26,6 +26,7 @@ import 'package:privacy_gui/page/instant_device/views/device_list_widget.dart'; import 'package:privacy_gui/page/instant_device/views/devices_filter_widget.dart'; import 'package:privacy_gui/page/nodes/_nodes.dart'; import 'package:privacy_gui/page/nodes/views/blink_node_light_widget.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; import 'package:privacy_gui/route/constants.dart'; import 'package:privacy_gui/core/utils/device_image_helper.dart'; import 'package:privacy_gui/utils.dart'; @@ -345,6 +346,9 @@ class _NodeDetailViewState extends ConsumerState Widget _avatarCard(NodeDetailState state) { final isOnline = ref.watch(internetStatusProvider) == InternetStatus.online; + final isRemoteReadOnly = ref.watch( + remoteAccessProvider.select((state) => state.isRemoteReadOnly), + ); return _nodeDetailBackgroundCard( child: SizedBox( // height: 160, @@ -367,11 +371,18 @@ class _NodeDetailViewState extends ConsumerState ), _avatarInfoCard( title: state.location, - trailing: AppIconButton( - icon: AppIcon.font(AppFontIcons.edit), - onTap: () { - _showEditNodeNameDialog(state); - }, + trailing: Tooltip( + message: isRemoteReadOnly + ? loc(context).featureUnavailableInRemoteMode + : '', + child: AppIconButton( + icon: AppIcon.font(AppFontIcons.edit), + onTap: isRemoteReadOnly + ? null + : () { + _showEditNodeNameDialog(state); + }, + ), ), ), _avatarInfoCard( diff --git a/lib/page/vpn/views/vpn_status_tile.dart b/lib/page/vpn/views/vpn_status_tile.dart index 8f98153ec..67b00378d 100644 --- a/lib/page/vpn/views/vpn_status_tile.dart +++ b/lib/page/vpn/views/vpn_status_tile.dart @@ -4,6 +4,7 @@ import 'package:go_router/go_router.dart'; import 'package:privacy_gui/core/data/providers/device_manager_provider.dart'; import 'package:privacy_gui/localization/localization_hook.dart'; import 'package:privacy_gui/page/components/shortcuts/dialogs.dart'; +import 'package:privacy_gui/page/components/views/remote_aware_switch.dart'; import 'package:privacy_gui/page/dashboard/_dashboard.dart'; import 'package:privacy_gui/page/vpn/models/vpn_models.dart'; import 'package:privacy_gui/page/vpn/providers/vpn_notifier.dart'; @@ -56,7 +57,7 @@ class _VPNStatusTile extends ConsumerState { children: [ AppText.titleMedium(loc(context).vpn), AppGap.sm(), - AppSwitch( + RemoteAwareSwitch( value: vpnState.settings.serviceSettings.enabled, onChanged: (value) { final settings = vpnState.settings.serviceSettings; diff --git a/lib/providers/remote_access/remote_access_provider.dart b/lib/providers/remote_access/remote_access_provider.dart new file mode 100644 index 000000000..2e50c6713 --- /dev/null +++ b/lib/providers/remote_access/remote_access_provider.dart @@ -0,0 +1,30 @@ +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:privacy_gui/constants/build_config.dart'; +import 'package:privacy_gui/providers/auth/auth_provider.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_state.dart'; + +/// Provider that determines if the application is in remote read-only mode. +/// +/// Remote read-only mode is activated when any of these conditions are met: +/// 1. User logged in remotely via Cloud (loginType == LoginType.remote) +/// 2. Compile-time forced remote mode (BuildConfig.forceCommandType == ForceCommand.remote) +/// +/// When in remote read-only mode, all router configuration changes (JNAP SET operations) +/// are disabled for security reasons. +final remoteAccessProvider = Provider((ref) { + // Watch auth state for loginType changes + final authAsync = ref.watch(authProvider); + + // Extract loginType, default to LoginType.none if not available + final loginType = authAsync.when( + data: (authState) => authState.loginType, + loading: () => LoginType.none, + error: (_, __) => LoginType.none, + ); + + // Determine if remote read-only mode should be active + final isRemoteReadOnly = loginType == LoginType.remote || + BuildConfig.forceCommandType == ForceCommand.remote; + + return RemoteAccessState(isRemoteReadOnly: isRemoteReadOnly); +}); diff --git a/lib/providers/remote_access/remote_access_state.dart b/lib/providers/remote_access/remote_access_state.dart new file mode 100644 index 000000000..f49d792cd --- /dev/null +++ b/lib/providers/remote_access/remote_access_state.dart @@ -0,0 +1,54 @@ +import 'dart:convert'; +import 'package:equatable/equatable.dart'; + +/// Represents the remote access state of the application. +/// +/// This immutable class holds information about whether the application +/// is currently in remote read-only mode, where router configuration +/// changes are disabled for security reasons. +class RemoteAccessState extends Equatable { + /// Whether the application is in remote read-only mode. + /// + /// When true, all router configuration changes (JNAP SET operations) + /// should be disabled in the UI and blocked at the service layer. + final bool isRemoteReadOnly; + + const RemoteAccessState({ + required this.isRemoteReadOnly, + }); + + /// Creates a copy of this [RemoteAccessState] with the given fields replaced. + /// + /// Any parameter that is not provided will retain its current value. + RemoteAccessState copyWith({ + bool? isRemoteReadOnly, + }) { + return RemoteAccessState( + isRemoteReadOnly: isRemoteReadOnly ?? this.isRemoteReadOnly, + ); + } + + /// Creates a [RemoteAccessState] from a JSON map. + factory RemoteAccessState.fromMap(Map map) { + return RemoteAccessState( + isRemoteReadOnly: map['isRemoteReadOnly'] as bool? ?? false, + ); + } + + /// Creates a [RemoteAccessState] from a JSON string. + factory RemoteAccessState.fromJson(String source) => + RemoteAccessState.fromMap(jsonDecode(source) as Map); + + /// Converts this [RemoteAccessState] to a JSON map. + Map toMap() { + return { + 'isRemoteReadOnly': isRemoteReadOnly, + }; + } + + /// Converts this [RemoteAccessState] to a JSON string. + String toJson() => jsonEncode(toMap()); + + @override + List get props => [isRemoteReadOnly]; +} diff --git a/test/core/jnap/router_repository_test.dart b/test/core/jnap/router_repository_test.dart new file mode 100644 index 000000000..7fd329d24 --- /dev/null +++ b/test/core/jnap/router_repository_test.dart @@ -0,0 +1,617 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:privacy_gui/core/errors/service_error.dart'; +import 'package:privacy_gui/core/jnap/actions/better_action.dart'; +import 'package:privacy_gui/core/jnap/actions/jnap_transaction.dart'; +import 'package:privacy_gui/core/jnap/router_repository.dart'; +import 'package:privacy_gui/providers/auth/auth_provider.dart'; +import 'package:privacy_gui/providers/auth/auth_state.dart'; +import 'package:privacy_gui/providers/auth/auth_types.dart'; + +// Test helper to create AuthNotifier with specific state +class TestAuthNotifier extends AuthNotifier { + final AsyncValue testState; + + TestAuthNotifier(this.testState); + + @override + Future build() async { + state = testState; + return testState.when( + data: (data) => data, + loading: () => AuthState.empty(), + error: (_, __) => AuthState.empty(), + ); + } +} + +void main() { + // Initialize JNAP action map before all tests + setUpAll(() { + initBetterActions(); + }); + + group('RouterRepository - Remote Read-Only Mode Defensive Checks', () { + test('send() throws UnexpectedError when calling SET action in remote mode', + () async { + // Arrange: Create container with remote login state + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + + // Act & Assert: Attempt to call SET operation should throw immediately + try { + await repository.send(JNAPAction.setWANSettings); + fail('Expected UnexpectedError to be thrown'); + } on UnexpectedError catch (e) { + // Success - the defensive check caught it + expect( + e.message, + 'Write operations are not allowed in remote read-only mode', + ); + } catch (e) { + fail('Expected UnexpectedError but got: ${e.runtimeType}: $e'); + } + }); + + test( + 'send() throws UnexpectedError for various SET operations in remote mode', + () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + + // Act & Assert: Test multiple SET operations + final setActions = [ + JNAPAction.setWANSettings, + JNAPAction.setRadioSettings, + JNAPAction.setGuestNetworkSettings, + JNAPAction.setDMZSettings, + JNAPAction.setFirewallSettings, + JNAPAction.setDeviceProperties, + ]; + + for (final action in setActions) { + try { + await repository.send(action); + fail('Expected UnexpectedError for ${action.name}'); + } on UnexpectedError catch (e) { + // Success + expect(e.message, contains('remote read-only')); + } catch (e) { + fail( + 'Expected UnexpectedError for ${action.name} but got: ${e.runtimeType}'); + } + } + }); + + test('send() does not throw for GET operations in remote mode', () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + + // Act & Assert: GET operations should NOT throw our defensive error + // They will fail later due to lack of network/bindings, but that's expected + try { + await repository.send(JNAPAction.getWANSettings); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('GET operation should not be blocked by defensive check'); + } + // Other UnexpectedErrors are OK (missing network, etc) + } catch (e) { + // Expected: Will fail due to missing network/SharedPreferences/etc + // But NOT because of our remote read-only check + expect(e, isNot(isA())); + } + }); + + test('send() allows SET operations in local mode', () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.local), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + + // Act & Assert: SET operations in local mode should NOT throw our defensive error + try { + await repository.send(JNAPAction.setWANSettings); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('SET operation in local mode should not be blocked'); + } + // Other UnexpectedErrors are OK + } catch (e) { + // Expected: Will fail due to missing network/SharedPreferences/etc + // But NOT because of our remote read-only check + expect( + e, + isNot(isA().having( + (e) => e.message, + 'message', + contains('remote read-only'), + ))); + } + }); + + test('send() allows read-only operations in remote mode', () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + + // Act & Assert: Should NOT throw for safe read operations + try { + await repository.send(JNAPAction.getDeviceInfo); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail( + 'Read-only GET operation should not be blocked by defensive check'); + } + // Other UnexpectedErrors are OK (missing network, etc) + } catch (e) { + // Expected: Will fail due to missing network/SharedPreferences/etc + // But NOT because of our remote read-only check + } + + try { + await repository.send(JNAPAction.getWANSettings); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail( + 'Read-only GET operation should not be blocked by defensive check'); + } + } catch (e) { + // Expected: Will fail due to missing network/SharedPreferences/etc + } + + try { + await repository.send(JNAPAction.isAdminPasswordDefault); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail( + 'Read-only IS operation should not be blocked by defensive check'); + } + } catch (e) { + // Expected: Will fail due to missing network/SharedPreferences/etc + } + }); + + test('send() blocks destructive operations like reboot in remote mode', + () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + + // Act & Assert - Should throw for destructive operations + expect( + () => repository.send(JNAPAction.reboot), + throwsA(isA().having( + (e) => e.message, + 'message', + 'Write operations are not allowed in remote read-only mode', + )), + ); + + expect( + () => repository.send(JNAPAction.factoryReset), + throwsA(isA().having( + (e) => e.message, + 'message', + 'Write operations are not allowed in remote read-only mode', + )), + ); + + expect( + () => repository.send(JNAPAction.deleteDevice), + throwsA(isA().having( + (e) => e.message, + 'message', + 'Write operations are not allowed in remote read-only mode', + )), + ); + }); + + test( + 'transaction() throws UnexpectedError when transaction contains SET operation in remote mode', + () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + final builder = JNAPTransactionBuilder(commands: [ + MapEntry(JNAPAction.getWANSettings, {}), + MapEntry(JNAPAction.setWANSettings, {'test': 'data'}), + ]); + + // Act & Assert + try { + await repository.transaction(builder); + fail('Expected UnexpectedError to be thrown'); + } on UnexpectedError catch (e) { + expect( + e.message, + 'Write operations are not allowed in remote read-only mode', + ); + } catch (e) { + fail('Expected UnexpectedError but got: ${e.runtimeType}: $e'); + } + }); + + test( + 'transaction() throws UnexpectedError even if SET operation is not the first command', + () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + final builder = JNAPTransactionBuilder(commands: [ + MapEntry(JNAPAction.getDeviceInfo, {}), + MapEntry(JNAPAction.getWANSettings, {}), + MapEntry(JNAPAction.setRadioSettings, {'test': 'data'}), + ]); + + // Act & Assert + try { + await repository.transaction(builder); + fail('Expected UnexpectedError to be thrown'); + } on UnexpectedError catch (e) { + expect(e.message, contains('remote read-only')); + } catch (e) { + fail('Expected UnexpectedError but got: ${e.runtimeType}'); + } + }); + + test('transaction() allows only GET operations in remote mode', () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + final builder = JNAPTransactionBuilder(commands: [ + MapEntry(JNAPAction.getWANSettings, {}), + MapEntry(JNAPAction.getDeviceInfo, {}), + MapEntry(JNAPAction.getRadioInfo, {}), + ]); + + // Act & Assert: Should NOT throw our defensive error + try { + await repository.transaction(builder); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('GET-only transaction should not be blocked'); + } + } catch (e) { + // Expected: Will fail due to missing network/SharedPreferences/etc + } + }); + + test('transaction() allows SET operations in local mode', () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.local), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + final builder = JNAPTransactionBuilder(commands: [ + MapEntry(JNAPAction.getWANSettings, {}), + MapEntry(JNAPAction.setWANSettings, {'test': 'data'}), + MapEntry(JNAPAction.setRadioSettings, {'test': 'data'}), + ]); + + // Act & Assert: Should NOT throw our defensive error in local mode + try { + await repository.transaction(builder); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('SET operations in local mode should not be blocked'); + } + } catch (e) { + // Expected: Will fail due to missing network/SharedPreferences/etc + expect( + e, + isNot(isA().having( + (e) => e.message, + 'message', + contains('remote read-only'), + ))); + } + }); + + test('send() allows LED blinking operations in remote mode', () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + + // Act & Assert: LED blinking operations should NOT throw defensive error + // StartBlinkingNodeLed + try { + await repository.send(JNAPAction.startBlinkingNodeLed); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('LED blinking should not be blocked in remote mode'); + } + } catch (e) { + // Expected: Will fail due to missing network/etc + } + + // StopBlinkingNodeLed + try { + await repository.send(JNAPAction.stopBlinkingNodeLed); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('LED blinking should not be blocked in remote mode'); + } + } catch (e) { + // Expected: Will fail due to missing network/etc + } + }); + + test('send() allows speed test operations in remote mode', () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + + // Act & Assert: Speed test operations should NOT throw defensive error + // GetHealthCheckResults + try { + await repository.send(JNAPAction.getHealthCheckResults); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('GetHealthCheckResults should not be blocked in remote mode'); + } + } catch (e) { + // Expected: Will fail due to missing network/etc + } + + // RunHealthCheck + try { + await repository.send(JNAPAction.runHealthCheck); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('RunHealthCheck should not be blocked in remote mode'); + } + } catch (e) { + // Expected: Will fail due to missing network/etc + } + + // StopHealthCheck + try { + await repository.send(JNAPAction.stopHealthCheck); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('StopHealthCheck should not be blocked in remote mode'); + } + } catch (e) { + // Expected: Will fail due to missing network/etc + } + }); + + test('send() allows ping operations in remote mode', () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + + // Act & Assert: Ping operations should NOT throw defensive error + // StartPing + try { + await repository.send(JNAPAction.startPing); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('StartPing should not be blocked in remote mode'); + } + } catch (e) { + // Expected: Will fail due to missing network/etc + } + + // StopPing + try { + await repository.send(JNAPAction.stopPing); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('StopPing should not be blocked in remote mode'); + } + } catch (e) { + // Expected: Will fail due to missing network/etc + } + + // GetPingStatus + try { + await repository.send(JNAPAction.getPingStatus); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('GetPingStatus should not be blocked in remote mode'); + } + } catch (e) { + // Expected: Will fail due to missing network/etc + } + }); + + test('send() allows traceroute operations in remote mode', () async { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + final repository = container.read(routerRepositoryProvider); + + // Act & Assert: Traceroute operations should NOT throw defensive error + // StartTracroute + try { + await repository.send(JNAPAction.startTracroute); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('StartTracroute should not be blocked in remote mode'); + } + } catch (e) { + // Expected: Will fail due to missing network/etc + } + + // StopTracroute + try { + await repository.send(JNAPAction.stopTracroute); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('StopTracroute should not be blocked in remote mode'); + } + } catch (e) { + // Expected: Will fail due to missing network/etc + } + + // GetTracerouteStatus + try { + await repository.send(JNAPAction.getTracerouteStatus); + fail('Expected error due to missing network, but got success'); + } on UnexpectedError catch (e) { + if (e.message?.contains('remote read-only') ?? false) { + fail('GetTracerouteStatus should not be blocked in remote mode'); + } + } catch (e) { + // Expected: Will fail due to missing network/etc + } + }); + }); +} diff --git a/test/page/components/views/remote_aware_switch_test.dart b/test/page/components/views/remote_aware_switch_test.dart new file mode 100644 index 000000000..450dc9a85 --- /dev/null +++ b/test/page/components/views/remote_aware_switch_test.dart @@ -0,0 +1,201 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:privacy_gui/page/components/views/remote_aware_switch.dart'; +import 'package:privacy_gui/providers/auth/auth_provider.dart'; +import 'package:privacy_gui/providers/auth/auth_state.dart'; +import 'package:privacy_gui/providers/auth/auth_types.dart'; +import 'package:ui_kit_library/ui_kit.dart'; + +// Test helper to create AuthNotifier with specific state +class TestAuthNotifier extends AuthNotifier { + final AsyncValue testState; + + TestAuthNotifier(this.testState); + + @override + Future build() async { + state = testState; + return testState.when( + data: (data) => data, + loading: () => AuthState.empty(), + error: (_, __) => AuthState.empty(), + ); + } +} + +void main() { + group('RemoteAwareSwitch', () { + testWidgets('is enabled in local mode', (WidgetTester tester) async { + bool? callbackValue; + + await tester.pumpWidget( + ProviderScope( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.local), + ), + )), + ], + child: MaterialApp( + theme: ThemeData( + extensions: [ + GlassDesignTheme.light(), + ], + ), + home: Scaffold( + body: RemoteAwareSwitch( + value: false, + onChanged: (value) { + callbackValue = value; + }, + ), + ), + ), + ), + ); + + // Find the switch + final switchFinder = find.byType(AppSwitch); + expect(switchFinder, findsOneWidget); + + // Get the switch widget + final appSwitch = tester.widget(switchFinder); + + // Verify onChanged is not null (enabled) + expect(appSwitch.onChanged, isNotNull); + + // Trigger the callback + appSwitch.onChanged?.call(true); + + // Verify callback was invoked + expect(callbackValue, true); + }); + + testWidgets('is disabled in remote mode', (WidgetTester tester) async { + bool? callbackValue; + + await tester.pumpWidget( + ProviderScope( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + child: MaterialApp( + theme: ThemeData( + extensions: [ + GlassDesignTheme.light(), + ], + ), + home: Scaffold( + body: RemoteAwareSwitch( + value: false, + onChanged: (value) { + callbackValue = value; + }, + ), + ), + ), + ), + ); + + // Find the switch + final switchFinder = find.byType(AppSwitch); + expect(switchFinder, findsOneWidget); + + // Get the switch widget + final appSwitch = tester.widget(switchFinder); + + // Verify onChanged is null (disabled) + expect(appSwitch.onChanged, isNull); + }); + + testWidgets('displays correct value in remote mode', + (WidgetTester tester) async { + await tester.pumpWidget( + ProviderScope( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + child: MaterialApp( + theme: ThemeData( + extensions: [ + GlassDesignTheme.light(), + ], + ), + home: Scaffold( + body: RemoteAwareSwitch( + value: true, + onChanged: (value) {}, + ), + ), + ), + ), + ); + + // Find the switch + final switchFinder = find.byType(AppSwitch); + expect(switchFinder, findsOneWidget); + + // Get the switch widget + final appSwitch = tester.widget(switchFinder); + + // Verify value is preserved + expect(appSwitch.value, true); + + // Verify it's disabled + expect(appSwitch.onChanged, isNull); + }); + + testWidgets('updates state when loginType changes', + (WidgetTester tester) async { + // Create a notifier we can control + final authNotifier = TestAuthNotifier( + const AsyncValue.data(AuthState(loginType: LoginType.local)), + ); + + await tester.pumpWidget( + ProviderScope( + overrides: [ + authProvider.overrideWith(() => authNotifier), + ], + child: MaterialApp( + theme: ThemeData( + extensions: [ + GlassDesignTheme.light(), + ], + ), + home: Scaffold( + body: RemoteAwareSwitch( + value: false, + onChanged: (value) {}, + ), + ), + ), + ), + ); + + // Initially enabled (local mode) + var appSwitch = tester.widget(find.byType(AppSwitch)); + expect(appSwitch.onChanged, isNotNull); + + // Change to remote mode + authNotifier.state = const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ); + await tester.pump(); + + // Now should be disabled + appSwitch = tester.widget(find.byType(AppSwitch)); + expect(appSwitch.onChanged, isNull); + }); + }); +} diff --git a/test/page/components/views/remote_read_only_banner_test.dart b/test/page/components/views/remote_read_only_banner_test.dart new file mode 100644 index 000000000..fd5bf7fb2 --- /dev/null +++ b/test/page/components/views/remote_read_only_banner_test.dart @@ -0,0 +1,104 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:privacy_gui/page/components/views/remote_read_only_banner.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_state.dart'; +import 'package:privacy_gui/l10n/gen/app_localizations.dart'; + +void main() { + group('RemoteReadOnlyBanner', () { + testWidgets('shows banner when isRemoteReadOnly is true', + (WidgetTester tester) async { + // Arrange + await tester.pumpWidget( + ProviderScope( + overrides: [ + remoteAccessProvider.overrideWith( + (ref) => const RemoteAccessState(isRemoteReadOnly: true), + ), + ], + child: const MaterialApp( + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + home: Scaffold( + body: RemoteReadOnlyBanner(), + ), + ), + ), + ); + + // Assert + expect(find.byType(Container), findsOneWidget); + expect(find.byIcon(Icons.info_outline), findsOneWidget); + expect( + find.text('Remote View Mode - Setting changes are disabled'), + findsOneWidget, + ); + }); + + testWidgets('hides banner when isRemoteReadOnly is false', + (WidgetTester tester) async { + // Arrange + await tester.pumpWidget( + ProviderScope( + overrides: [ + remoteAccessProvider.overrideWith( + (ref) => const RemoteAccessState(isRemoteReadOnly: false), + ), + ], + child: const MaterialApp( + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + home: Scaffold( + body: RemoteReadOnlyBanner(), + ), + ), + ), + ); + + // Assert + expect(find.byType(SizedBox), findsOneWidget); + expect(find.byIcon(Icons.info_outline), findsNothing); + expect( + find.text('Remote View Mode - Setting changes are disabled'), + findsNothing, + ); + }); + + testWidgets('banner has correct styling', (WidgetTester tester) async { + // Arrange + await tester.pumpWidget( + ProviderScope( + overrides: [ + remoteAccessProvider.overrideWith( + (ref) => const RemoteAccessState(isRemoteReadOnly: true), + ), + ], + child: const MaterialApp( + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + home: Scaffold( + body: RemoteReadOnlyBanner(), + ), + ), + ), + ); + + // Act + final context = tester.element(find.byType(RemoteReadOnlyBanner)); + final colorScheme = Theme.of(context).colorScheme; + final banner = find.byType(RemoteReadOnlyBanner); + final bannerSize = tester.getSize(banner); + final container = tester.widget(find.byType(Container).first); + + // Assert + // Verify banner takes full available width + expect(bannerSize.width, greaterThan(0)); + + // Verify decoration uses theme colors + final decoration = container.decoration as BoxDecoration?; + expect(decoration?.color, equals(colorScheme.errorContainer)); + }); + }); +} diff --git a/test/providers/remote_access/remote_access_provider_test.dart b/test/providers/remote_access/remote_access_provider_test.dart new file mode 100644 index 000000000..94c20e492 --- /dev/null +++ b/test/providers/remote_access/remote_access_provider_test.dart @@ -0,0 +1,151 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:privacy_gui/constants/build_config.dart'; +import 'package:privacy_gui/providers/auth/auth_provider.dart'; +import 'package:privacy_gui/providers/auth/auth_state.dart'; +import 'package:privacy_gui/providers/auth/auth_types.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_provider.dart'; + +// Test helper to create AuthNotifier with specific state +class TestAuthNotifier extends AuthNotifier { + final AsyncValue testState; + + TestAuthNotifier(this.testState); + + @override + Future build() async { + state = testState; + return testState.when( + data: (data) => data, + loading: () => AuthState.empty(), + error: (_, __) => AuthState.empty(), + ); + } +} + +void main() { + group('remoteAccessProvider', () { + test('returns isRemoteReadOnly true when loginType is remote', () { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.remote), + ), + )), + ], + ); + addTearDown(container.dispose); + + // Act + final state = container.read(remoteAccessProvider); + + // Assert + expect(state.isRemoteReadOnly, true); + }); + + test('returns isRemoteReadOnly false when loginType is local', () { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.local), + ), + )), + ], + ); + addTearDown(container.dispose); + + // Act + final state = container.read(remoteAccessProvider); + + // Assert + expect(state.isRemoteReadOnly, false); + }); + + test('returns isRemoteReadOnly false when loginType is none', () { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.none), + ), + )), + ], + ); + addTearDown(container.dispose); + + // Act + final state = container.read(remoteAccessProvider); + + // Assert + expect(state.isRemoteReadOnly, false); + }); + + test('returns isRemoteReadOnly true when forceCommandType is remote', () { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier( + const AsyncValue.data( + AuthState(loginType: LoginType.local), + ), + )), + ], + ); + addTearDown(container.dispose); + + // Act + final state = container.read(remoteAccessProvider); + + // Assert + // If BuildConfig.forceCommandType is ForceCommand.remote, this should be true + // Otherwise, it should be false (based on loginType.local) + expect( + state.isRemoteReadOnly, + BuildConfig.forceCommandType == ForceCommand.remote, + ); + }); + + test('handles authProvider loading state gracefully', () { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider + .overrideWith(() => TestAuthNotifier(const AsyncValue.loading())), + ], + ); + addTearDown(container.dispose); + + // Act + final state = container.read(remoteAccessProvider); + + // Assert + // Should default to false when auth is loading + expect(state.isRemoteReadOnly, false); + }); + + test('handles authProvider error state gracefully', () { + // Arrange + final container = ProviderContainer( + overrides: [ + authProvider.overrideWith(() => TestAuthNotifier(AsyncValue.error( + Exception('Auth error'), + StackTrace.current, + ))), + ], + ); + addTearDown(container.dispose); + + // Act + final state = container.read(remoteAccessProvider); + + // Assert + // Should default to false when auth has error + expect(state.isRemoteReadOnly, false); + }); + }); +} diff --git a/test/providers/remote_access/remote_access_state_test.dart b/test/providers/remote_access/remote_access_state_test.dart new file mode 100644 index 000000000..042e4c569 --- /dev/null +++ b/test/providers/remote_access/remote_access_state_test.dart @@ -0,0 +1,103 @@ +import 'dart:convert'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:privacy_gui/providers/remote_access/remote_access_state.dart'; + +void main() { + group('RemoteAccessState', () { + test('can be instantiated with isRemoteReadOnly', () { + const state = RemoteAccessState(isRemoteReadOnly: true); + expect(state.isRemoteReadOnly, true); + }); + + test('can be instantiated with isRemoteReadOnly false', () { + const state = RemoteAccessState(isRemoteReadOnly: false); + expect(state.isRemoteReadOnly, false); + }); + + group('toMap / fromMap', () { + test('toMap serializes correctly', () { + const state = RemoteAccessState(isRemoteReadOnly: true); + final map = state.toMap(); + expect(map, {'isRemoteReadOnly': true}); + }); + + test('fromMap deserializes correctly', () { + final map = {'isRemoteReadOnly': false}; + final state = RemoteAccessState.fromMap(map); + expect(state.isRemoteReadOnly, false); + }); + + test('fromMap handles missing key with default false', () { + final map = {}; + final state = RemoteAccessState.fromMap(map); + expect(state.isRemoteReadOnly, false); + }); + }); + + group('toJson / fromJson', () { + test('toJson serializes correctly', () { + const state = RemoteAccessState(isRemoteReadOnly: true); + final json = state.toJson(); + expect(json, '{"isRemoteReadOnly":true}'); + }); + + test('fromJson deserializes correctly', () { + const json = '{"isRemoteReadOnly":false}'; + final state = RemoteAccessState.fromJson(json); + expect(state.isRemoteReadOnly, false); + }); + }); + + group('equality', () { + test('two states with same isRemoteReadOnly are equal', () { + const state1 = RemoteAccessState(isRemoteReadOnly: true); + const state2 = RemoteAccessState(isRemoteReadOnly: true); + expect(state1, equals(state2)); + expect(state1.hashCode, equals(state2.hashCode)); + }); + + test('two states with different isRemoteReadOnly are not equal', () { + const state1 = RemoteAccessState(isRemoteReadOnly: true); + const state2 = RemoteAccessState(isRemoteReadOnly: false); + expect(state1, isNot(equals(state2))); + }); + }); + + group('copyWith', () { + test('preserves original value when no parameter provided', () { + // Arrange + const original = RemoteAccessState(isRemoteReadOnly: true); + + // Act + final copied = original.copyWith(); + + // Assert + expect(copied.isRemoteReadOnly, true); + }); + + test('updates isRemoteReadOnly when provided', () { + // Arrange + const original = RemoteAccessState(isRemoteReadOnly: true); + + // Act + final updated = original.copyWith(isRemoteReadOnly: false); + + // Assert + expect(updated.isRemoteReadOnly, false); + }); + + test('creates new instance, not mutation', () { + // Arrange + const original = RemoteAccessState(isRemoteReadOnly: true); + + // Act + final updated = original.copyWith(isRemoteReadOnly: false); + + // Assert + expect(original.isRemoteReadOnly, true); // Original unchanged + expect(updated.isRemoteReadOnly, false); // Updated changed + expect(identical(original, updated), isFalse); // Different instances + }); + }); + }); +}