void main() {
  runApp(MyApp());
}


class MyApp extends StatelessWidget {

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Material App',
      home: Scaffold(
        appBar: AppBar(
          title: Text('Material App Bar'),
        ),
        body: CustomInput(),
      ),
    );
  }
}

class CustomInput extends StatefulWidget {
  @override
  _CustomInputState createState() => _CustomInputState();
}

class _CustomInputState extends State<CustomInput>
    with AutomaticKeepAliveClientMixin {
  TextInputConnection _textInputConnection;

  FocusNode _focusNode;

  FocusAttachment _focusAttachment;

  InputConnectionController _input;

  void requestKeyboard() {
    if (_focusNode.hasFocus) {
      _input.openConnection(Brightness.dark);
    } else {
      FocusScope.of(context).requestFocus(_focusNode);
    }
  }

  void focusOrUnfocusIfNeeded() {
    if (_focusNode.hasFocus) {
      _focusNode.unfocus();
    }
  }

  @override
  bool get wantKeepAlive => _focusNode.hasFocus;

  void _handleFocusChange() {
    if (_focusNode.hasFocus && _focusNode.consumeKeyboardToken()) {
      _input.openConnection(Brightness.dark);
    } else if (!_focusNode.hasFocus) {
      _input.closeConnection();
    }
    updateKeepAlive();
  }


  bool get _hasFocus => _focusNode.hasFocus;

  bool get _hasInputConnection =>
      _textInputConnection != null && _textInputConnection.attached;

  @override
  void initState() {
    _focusNode = FocusNode();
    super.initState();
    _focusAttachment = _focusNode.attach(context);
    _input = InputConnectionController();
    _focusNode.addListener(_handleFocusChange);
  }

  @override
  void dispose() {
    _focusAttachment.detach();
    _focusNode.removeListener(_handleFocusChange);
    _input.closeConnection();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    _focusAttachment.reparent();
    super.build(context); // See AutomaticKeepAliveState.

    return GestureDetector(
      onTap: () => _focusNode.requestFocus(),
      child: Container(
        width: 200,
        height: 200,
        color: Colors.red,
      ),
    );
  }
}

class InputConnectionController implements TextInputClient {
  TextInputConnection _textInputConnection;

  bool get hasConnection =>
      _textInputConnection != null && _textInputConnection.attached;

  void openOrCloseConnection(
      FocusNode focusNode, Brightness keyboardAppearance) {
    if (focusNode.hasFocus && focusNode.consumeKeyboardToken()) {
      openConnection(keyboardAppearance);
    } else if (!focusNode.hasFocus) {
      closeConnection();
    }
  }

  void openConnection(Brightness keyboardAppearance) {
    if (!hasConnection) {
      _textInputConnection = TextInput.attach(
        this,
        TextInputConfiguration(
          inputType: TextInputType.multiline,
          obscureText: false,
          autocorrect: false,
          inputAction: TextInputAction.newline,
          keyboardAppearance: keyboardAppearance,
          textCapitalization: TextCapitalization.sentences,
        ),
      );
    }
    _textInputConnection.show();
  }

  void closeConnection() {
    if (hasConnection) {
      _textInputConnection.close();
      _textInputConnection = null;
    }
  }

  @override
  void connectionClosed() {
    _textInputConnection.connectionClosedReceived();
    _textInputConnection = null;
  }

  @override
  AutofillScope get currentAutofillScope => null;

  @override
  TextEditingValue get currentTextEditingValue => null;

  @override
  void performAction(TextInputAction action) { }

  @override
  void showAutocorrectionPromptRect(int start, int end) {}

  @override
  void updateEditingValue(TextEditingValue value) {
    print('Composing range: ${value.composing.start} to ${value.composing.end}');
  }

  @override
  void updateFloatingCursor(RawFloatingCursorPoint point) {}

  @override
  void performPrivateCommand(String action, Map<String, dynamic> data) {}
}