| // Copyright 2019 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| import 'package:flutter_test/flutter_test.dart'; |
| import 'package:flutter/widgets.dart'; |
| |
| class TestFocusable extends StatefulWidget { |
| const TestFocusable({ |
| Key key, |
| this.name = 'a', |
| this.autofocus = false, |
| }) : super(key: key); |
| |
| final String name; |
| final bool autofocus; |
| |
| @override |
| TestFocusableState createState() => TestFocusableState(); |
| } |
| |
| class TestFocusableState extends State<TestFocusable> { |
| final FocusNode focusNode = FocusNode(); |
| bool _didAutofocus = false; |
| |
| @override |
| void dispose() { |
| focusNode.dispose(); |
| super.dispose(); |
| } |
| |
| @override |
| Widget build(BuildContext context) { |
| FocusScope.of(context).reparentIfNeeded(focusNode); |
| if (!_didAutofocus && widget.autofocus) { |
| _didAutofocus = true; |
| FocusScope.of(context).autofocus(focusNode); |
| } |
| return GestureDetector( |
| onTap: () { |
| FocusScope.of(context).requestFocus(focusNode); |
| }, |
| child: AnimatedBuilder( |
| animation: focusNode, |
| builder: (BuildContext context, Widget child) { |
| return Text( |
| focusNode.hasFocus ? '${widget.name.toUpperCase()} FOCUSED' : widget.name.toLowerCase(), |
| textDirection: TextDirection.ltr, |
| ); |
| }, |
| ), |
| ); |
| } |
| } |
| |
| void main() { |
| testWidgets('Can focus', (WidgetTester tester) async { |
| final GlobalKey<TestFocusableState> key = GlobalKey(); |
| |
| await tester.pumpWidget( |
| TestFocusable(key: key, name: 'a'), |
| ); |
| |
| expect(key.currentState.focusNode.hasFocus, isFalse); |
| |
| FocusScope.of(key.currentContext).requestFocus(key.currentState.focusNode); |
| await tester.pumpAndSettle(); |
| |
| expect(key.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| }); |
| |
| testWidgets('Can unfocus', (WidgetTester tester) async { |
| final GlobalKey<TestFocusableState> keyA = GlobalKey(); |
| final GlobalKey<TestFocusableState> keyB = GlobalKey(); |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| TestFocusable(key: keyA, name: 'a'), |
| TestFocusable(key: keyB, name: 'b'), |
| ], |
| ), |
| ); |
| |
| expect(keyA.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('a'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| |
| FocusScope.of(keyA.currentContext).requestFocus(keyA.currentState.focusNode); |
| await tester.pumpAndSettle(); |
| |
| expect(keyA.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| |
| // Set focus to the "B" node to unfocus the "A" node. |
| FocusScope.of(keyB.currentContext).requestFocus(keyB.currentState.focusNode); |
| await tester.pumpAndSettle(); |
| |
| expect(keyA.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('a'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('B FOCUSED'), findsOneWidget); |
| }); |
| |
| testWidgets('Can have multiple focused children and they update accordingly', (WidgetTester tester) async { |
| final GlobalKey<TestFocusableState> keyA = GlobalKey(); |
| final GlobalKey<TestFocusableState> keyB = GlobalKey(); |
| |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyA, |
| name: 'a', |
| autofocus: true, |
| ), |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| ), |
| ], |
| ), |
| ); |
| |
| // Autofocus is delayed one frame. |
| await tester.pump(); |
| expect(keyA.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| await tester.tap(find.text('A FOCUSED')); |
| await tester.pump(); |
| expect(keyA.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| await tester.tap(find.text('b')); |
| await tester.pump(); |
| expect(keyA.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('a'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('B FOCUSED'), findsOneWidget); |
| await tester.tap(find.text('a')); |
| await tester.pump(); |
| expect(keyA.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| }); |
| |
| // This moves a focus node first into a focus scope that is added to its |
| // parent, and then out of that focus scope again. |
| testWidgets('Can move focus in and out of FocusScope', (WidgetTester tester) async { |
| final FocusScopeNode parentFocusScope = FocusScopeNode(); |
| final FocusScopeNode childFocusScope = FocusScopeNode(); |
| final GlobalKey<TestFocusableState> key = GlobalKey(); |
| |
| // Initially create the focus inside of the parent FocusScope. |
| await tester.pumpWidget( |
| FocusScope( |
| node: parentFocusScope, |
| autofocus: true, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable(key: key, name: 'a'), |
| ], |
| ), |
| ), |
| ); |
| |
| expect(key.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('a'), findsOneWidget); |
| FocusScope.of(key.currentContext).requestFocus(key.currentState.focusNode); |
| await tester.pumpAndSettle(); |
| |
| expect(key.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| |
| expect(parentFocusScope, hasAGoodToStringDeep); |
| expect( |
| parentFocusScope.toStringDeep(minLevel: DiagnosticLevel.info), |
| equalsIgnoringHashCodes('FocusScopeNode#00000\n' |
| ' focus: FocusNode#00000(FOCUSED)\n'), |
| ); |
| |
| expect(WidgetsBinding.instance.focusManager.rootScope, hasAGoodToStringDeep); |
| expect( |
| WidgetsBinding.instance.focusManager.rootScope.toStringDeep(minLevel: DiagnosticLevel.info), |
| equalsIgnoringHashCodes('FocusScopeNode#00000\n' |
| ' └─child 1: FocusScopeNode#00000\n' |
| ' focus: FocusNode#00000(FOCUSED)\n'), |
| ); |
| |
| // Add the child focus scope to the focus tree. |
| parentFocusScope.setFirstFocus(childFocusScope); |
| expect(childFocusScope.isFirstFocus, isTrue); |
| |
| // Now add the child focus scope with no focus node in it to the tree. |
| await tester.pumpWidget( |
| FocusScope( |
| node: parentFocusScope, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable(key: key), |
| FocusScope( |
| node: childFocusScope, |
| child: Container(), |
| ), |
| ], |
| ), |
| ), |
| ); |
| |
| expect(key.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('a'), findsOneWidget); |
| |
| // Now move the existing focus node into the child focus scope. |
| await tester.pumpWidget( |
| FocusScope( |
| node: parentFocusScope, |
| child: Column( |
| children: <Widget>[ |
| FocusScope( |
| node: childFocusScope, |
| child: TestFocusable(key: key), |
| ), |
| ], |
| ), |
| ), |
| ); |
| |
| await tester.pumpAndSettle(); |
| |
| expect(key.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| |
| // Now remove the child focus scope. |
| await tester.pumpWidget( |
| FocusScope( |
| node: parentFocusScope, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable(key: key), |
| ], |
| ), |
| ), |
| ); |
| |
| await tester.pumpAndSettle(); |
| |
| expect(key.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| }); |
| |
| // Arguably, this isn't correct behavior, but it is what happens now. |
| testWidgets("Removing focused widget doesn't move focus to next widget", (WidgetTester tester) async { |
| final GlobalKey<TestFocusableState> keyA = GlobalKey(); |
| final GlobalKey<TestFocusableState> keyB = GlobalKey(); |
| |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyA, |
| name: 'a', |
| ), |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| ), |
| ], |
| ), |
| ); |
| |
| FocusScope.of(keyA.currentContext).requestFocus(keyA.currentState.focusNode); |
| |
| await tester.pumpAndSettle(); |
| |
| expect(keyA.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| ), |
| ], |
| ), |
| ); |
| |
| await tester.pump(); |
| |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| }); |
| |
| testWidgets('Adding a new FocusScope attaches the child it to its parent.', (WidgetTester tester) async { |
| final GlobalKey<TestFocusableState> keyA = GlobalKey(); |
| final FocusScopeNode parentFocusScope = FocusScopeNode(); |
| final FocusScopeNode childFocusScope = FocusScopeNode(); |
| |
| await tester.pumpWidget( |
| FocusScope( |
| node: childFocusScope, |
| child: TestFocusable( |
| key: keyA, |
| name: 'a', |
| ), |
| ), |
| ); |
| |
| FocusScope.of(keyA.currentContext).requestFocus(keyA.currentState.focusNode); |
| WidgetsBinding.instance.focusManager.rootScope.setFirstFocus(FocusScope.of(keyA.currentContext)); |
| |
| await tester.pumpAndSettle(); |
| |
| expect(keyA.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| expect(childFocusScope.isFirstFocus, isTrue); |
| |
| await tester.pumpWidget( |
| FocusScope( |
| node: parentFocusScope, |
| child: FocusScope( |
| node: childFocusScope, |
| child: TestFocusable( |
| key: keyA, |
| name: 'a', |
| ), |
| ), |
| ), |
| ); |
| |
| await tester.pump(); |
| |
| expect(childFocusScope.isFirstFocus, isTrue); |
| expect(keyA.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('a'), findsOneWidget); |
| }); |
| |
| // Arguably, this isn't correct behavior, but it is what happens now. |
| testWidgets("Removing focused widget doesn't move focus to next widget within FocusScope", (WidgetTester tester) async { |
| final GlobalKey<TestFocusableState> keyA = GlobalKey(); |
| final GlobalKey<TestFocusableState> keyB = GlobalKey(); |
| final FocusScopeNode parentFocusScope = FocusScopeNode(); |
| |
| await tester.pumpWidget( |
| FocusScope( |
| node: parentFocusScope, |
| autofocus: true, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyA, |
| name: 'a', |
| ), |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| ), |
| ], |
| ), |
| ), |
| ); |
| |
| FocusScope.of(keyA.currentContext).requestFocus(keyA.currentState.focusNode); |
| WidgetsBinding.instance.focusManager.rootScope.setFirstFocus(FocusScope.of(keyA.currentContext)); |
| |
| await tester.pumpAndSettle(); |
| |
| expect(keyA.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| |
| await tester.pumpWidget( |
| FocusScope( |
| node: parentFocusScope, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| ), |
| ], |
| ), |
| ), |
| ); |
| |
| await tester.pump(); |
| |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| }); |
| |
| // By "pinned", it means kept in the tree by a GlobalKey. |
| testWidgets('Removing pinned focused scope moves focus to focused widget within next FocusScope', (WidgetTester tester) async { |
| final GlobalKey<TestFocusableState> keyA = GlobalKey(); |
| final GlobalKey<TestFocusableState> keyB = GlobalKey(); |
| final GlobalKey<TestFocusableState> scopeKeyA = GlobalKey(); |
| final GlobalKey<TestFocusableState> scopeKeyB = GlobalKey(); |
| final FocusScopeNode parentFocusScope1 = FocusScopeNode(); |
| final FocusScopeNode parentFocusScope2 = FocusScopeNode(); |
| |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| FocusScope( |
| key: scopeKeyA, |
| node: parentFocusScope1, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyA, |
| name: 'a', |
| ), |
| ], |
| ), |
| ), |
| FocusScope( |
| key: scopeKeyB, |
| node: parentFocusScope2, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| ), |
| ], |
| ), |
| ), |
| ], |
| ), |
| ); |
| |
| FocusScope.of(keyB.currentContext).requestFocus(keyB.currentState.focusNode); |
| FocusScope.of(keyA.currentContext).requestFocus(keyA.currentState.focusNode); |
| WidgetsBinding.instance.focusManager.rootScope.setFirstFocus(FocusScope.of(keyB.currentContext)); |
| WidgetsBinding.instance.focusManager.rootScope.setFirstFocus(FocusScope.of(keyA.currentContext)); |
| |
| await tester.pumpAndSettle(); |
| |
| expect(FocusScope.of(keyA.currentContext).isFirstFocus, isTrue); |
| expect(keyA.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| |
| // Since the FocusScope widgets are pinned with GlobalKeys, when the first |
| // one gets removed, the second one stays registered with the focus |
| // manager and ends up getting the focus since it remains as part of the |
| // focus tree. |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| FocusScope( |
| key: scopeKeyB, |
| node: parentFocusScope2, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| autofocus: true, |
| ), |
| ], |
| ), |
| ), |
| ], |
| ), |
| ); |
| |
| await tester.pump(); |
| |
| expect(keyB.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('B FOCUSED'), findsOneWidget); |
| }); |
| |
| // Arguably, this isn't correct behavior, but it is what happens now. |
| testWidgets("Removing unpinned focused scope doesn't move focus to focused widget within next FocusScope", (WidgetTester tester) async { |
| final GlobalKey<TestFocusableState> keyA = GlobalKey(); |
| final GlobalKey<TestFocusableState> keyB = GlobalKey(); |
| final FocusScopeNode parentFocusScope1 = FocusScopeNode(); |
| final FocusScopeNode parentFocusScope2 = FocusScopeNode(); |
| |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| FocusScope( |
| node: parentFocusScope1, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyA, |
| name: 'a', |
| ), |
| ], |
| ), |
| ), |
| FocusScope( |
| node: parentFocusScope2, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| ), |
| ], |
| ), |
| ), |
| ], |
| ), |
| ); |
| |
| FocusScope.of(keyB.currentContext).requestFocus(keyB.currentState.focusNode); |
| FocusScope.of(keyA.currentContext).requestFocus(keyA.currentState.focusNode); |
| WidgetsBinding.instance.focusManager.rootScope.setFirstFocus(FocusScope.of(keyB.currentContext)); |
| WidgetsBinding.instance.focusManager.rootScope.setFirstFocus(FocusScope.of(keyA.currentContext)); |
| |
| await tester.pumpAndSettle(); |
| |
| expect(FocusScope.of(keyA.currentContext).isFirstFocus, isTrue); |
| expect(keyA.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| |
| // If the FocusScope widgets are not pinned with GlobalKeys, then the first |
| // one remains and gets its guts replaced with the parentFocusScope2 and the |
| // "B" test widget, and in the process, the focus manager loses track of the |
| // focus. |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| FocusScope( |
| node: parentFocusScope2, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| autofocus: true, |
| ), |
| ], |
| ), |
| ), |
| ], |
| ), |
| ); |
| await tester.pump(); |
| |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| }); |
| |
| // Arguably, this isn't correct behavior, but it is what happens now. |
| testWidgets('Moving widget from one scope to another does not retain focus', (WidgetTester tester) async { |
| final FocusScopeNode parentFocusScope1 = FocusScopeNode(); |
| final FocusScopeNode parentFocusScope2 = FocusScopeNode(); |
| final GlobalKey<TestFocusableState> keyA = GlobalKey(); |
| final GlobalKey<TestFocusableState> keyB = GlobalKey(); |
| |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| FocusScope( |
| node: parentFocusScope1, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyA, |
| name: 'a', |
| ), |
| ], |
| ), |
| ), |
| FocusScope( |
| node: parentFocusScope2, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| ), |
| ], |
| ), |
| ), |
| ], |
| ), |
| ); |
| |
| FocusScope.of(keyA.currentContext).requestFocus(keyA.currentState.focusNode); |
| WidgetsBinding.instance.focusManager.rootScope.setFirstFocus(FocusScope.of(keyA.currentContext)); |
| |
| await tester.pumpAndSettle(); |
| |
| expect(keyA.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| FocusScope( |
| node: parentFocusScope1, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| ), |
| ], |
| ), |
| ), |
| FocusScope( |
| node: parentFocusScope2, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyA, |
| name: 'a', |
| ), |
| ], |
| ), |
| ), |
| ], |
| ), |
| ); |
| |
| await tester.pump(); |
| |
| expect(keyA.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('a'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| }); |
| |
| // Arguably, this isn't correct behavior, but it is what happens now. |
| testWidgets('Moving FocusScopeNodes does not retain focus', (WidgetTester tester) async { |
| final FocusScopeNode parentFocusScope1 = FocusScopeNode(); |
| final FocusScopeNode parentFocusScope2 = FocusScopeNode(); |
| final GlobalKey<TestFocusableState> keyA = GlobalKey(); |
| final GlobalKey<TestFocusableState> keyB = GlobalKey(); |
| |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| FocusScope( |
| node: parentFocusScope1, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyA, |
| name: 'a', |
| ), |
| ], |
| ), |
| ), |
| FocusScope( |
| node: parentFocusScope2, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| ), |
| ], |
| ), |
| ), |
| ], |
| ), |
| ); |
| |
| FocusScope.of(keyA.currentContext).requestFocus(keyA.currentState.focusNode); |
| WidgetsBinding.instance.focusManager.rootScope.setFirstFocus(FocusScope.of(keyA.currentContext)); |
| |
| await tester.pumpAndSettle(); |
| |
| expect(keyA.currentState.focusNode.hasFocus, isTrue); |
| expect(find.text('A FOCUSED'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| |
| // This just swaps the FocusScopeNodes that the FocusScopes have in them. |
| await tester.pumpWidget( |
| Column( |
| children: <Widget>[ |
| FocusScope( |
| node: parentFocusScope2, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyA, |
| name: 'a', |
| ), |
| ], |
| ), |
| ), |
| FocusScope( |
| node: parentFocusScope1, |
| child: Column( |
| children: <Widget>[ |
| TestFocusable( |
| key: keyB, |
| name: 'b', |
| ), |
| ], |
| ), |
| ), |
| ], |
| ), |
| ); |
| |
| await tester.pump(); |
| |
| expect(keyA.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('a'), findsOneWidget); |
| expect(keyB.currentState.focusNode.hasFocus, isFalse); |
| expect(find.text('b'), findsOneWidget); |
| }); |
| } |