// Поле с данными элементов перекрывающих дисплей
MediaQuery.of(context).viewInsets
// Отвечает за данные клавиатуры
MediaQuery.of(context).viewInsets.bottom

class KeyboardScreen extends StatefulWidget {
@override
_KeyboardScreenState createState() => _KeyboardScreenState();
}
class _KeyboardScreenState extends State<KeyboardScreen> {
@override
Widget build(BuildContext context) {
   return Scaffold(
     body: Column(
       mainAxisAlignment: MainAxisAlignment.center,
       children: [
         Text('Keyboard: ${MediaQuery.of(context).viewInsets.bottom}'),
         const SizedBox(height: 20),
         TextField(),
       ],
     ),
   );
}
}

static MediaQueryData of(BuildContext context, { bool nullOk = false }) {
assert(context != null);
assert(nullOk != null);
final MediaQuery query = context.dependOnInheritedWidgetOfExactType<MediaQuery>();
if (query != null)
   return query.data;
if (nullOk)
   return null;
throw FlutterError.fromParts(<DiagnosticsNode>[
   ErrorSummary('MediaQuery.of() called with a context that does not contain a MediaQuery.'),
   ErrorDescription(
   ),
   context.describeElement('The context used was')
]);
}

final MediaQuery query = context.dependOnInheritedWidgetOfExactType<MediaQuery>();

MediaQuery(
data: MediaQuery.of(context).copyWith(
   // iOS does not shrink dialog content below a 1.0 scale factor
   textScaleFactor: math.max(textScaleFactor, 1.0),
),

class _MediaQueryFromWindow extends StatefulWidget {
const _MediaQueryFromWindow({Key key, this.child}) : super(key: key);
final Widget child;
@override
_MediaQueryFromWindowsState createState() => _MediaQueryFromWindowsState();
}
class _MediaQueryFromWindowsState extends State<_MediaQueryFromWindow> with WidgetsBindingObserver {
@override
void initState() {
   super.initState();
   WidgetsBinding.instance.addObserver(this);
}
// ACCESSIBILITY
@override
void didChangeAccessibilityFeatures() {
setState(() {
   // The properties of window have changed. We use them in our build
   // function, so we need setState(), but we don't cache anything locally.
});
}
// METRICS
@override
void didChangeMetrics() {
setState(() {
   // The properties of window have changed. We use them in our build
   // function, so we need setState(), but we don't cache anything locally.
});
}
@override
void didChangeTextScaleFactor() {
setState(() {
   // The textScaleFactor property of window has changed. We reference
   // window in our build function, so we need to call setState(), but
   // we don't need to cache anything locally.
});
}
// RENDERING
@override
void didChangePlatformBrightness() {
setState(() {
   // The platformBrightness property of window has changed. We reference
   // window in our build function, so we need to call setState(), but
   // we don't need to cache anything locally.
});
}
@override
Widget build(BuildContext context) {
   MediaQueryData data = MediaQueryData.fromWindow(WidgetsBinding.instance.window);
   if (!kReleaseMode) {
     data = data.copyWith(platformBrightness: debugBrightnessOverride);
   }
   return MediaQuery(
     data: data,
     child: widget.child,
   );
}
@override
void dispose() {
   WidgetsBinding.instance.removeObserver(this);
   super.dispose();
}
}

Widget build(BuildContext context) {
MediaQueryData data = MediaQueryData.fromWindow(WidgetsBinding.instance.window);

class KeyboardListener with WidgetsBindingObserver {}

double get currentKeyboardHeight => _currentKeyboardHeight;
double _currentKeyboardHeight = 0;
bool get _isVisibleKeyboard => _currentKeyboardHeight > 0;
Future(() {
final double newKeyboardHeight =
     WidgetsBinding.instance.window.viewInsets.bottom;
if (newKeyboardHeight > _currentKeyboardHeight) {
   /// Новая высота больше предыдущей — клавиатура открылась
   _onShow();
   _onChange(true);
} else if (newKeyboardHeight < _currentKeyboardHeight) {
   /// Новая высота меньше предыдущей — клавиатура закрылась
   _onHide();
   _onChange(false);
}
_currentKeyboardHeight = newKeyboardHeight;
});

WidgetsBinding.instance.window.viewInsets.bottom > 0;

@override
void didChangeMetrics() {
_listener();
}
void _listener() {
if (isVisibleKeyboard) {
   _onChange(true);
} else {
   _onChange(false);
}
}
void _onChange(bool isOpen) {
/// Тут вызываются внешние слушатели
}

class _KeyboardScreenState extends State<KeyboardScreen> {
bool _isShowKeyboard = false;
KeyboardListener _keyboardListener = KeyboardListener();
@override
void initState() {
   super.initState();
   _keyboardListener.addListener(onChange: (bool isVisible) {
     setState(() {
       _isShowKeyboard = isVisible;
     });
   });
}
@override
void dispose() {
   _keyboardListener.dispose();
   super.dispose();
}
@override
Widget build(BuildContext context) {
   return Scaffold(
     body: Column(
       mainAxisAlignment: MainAxisAlignment.center,
       children: [
         Text('Keyboard: $_isShowKeyboard'),
         const SizedBox(height: 20),
         TextField(),
       ],
     ),
   );
}
}

import 'dart:math';
import 'dart:ui';
import 'package:flutter/widgets.dart';
typedef KeyboardChangeListener = Function(bool isVisible);
class KeyboardListener with WidgetsBindingObserver {
static final Random _random = Random();
/// Колбэки, вызывающиеся при появлении и сокрытии клавиатуры
final Map<String, KeyboardChangeListener> _changeListeners = {};
/// Колбэки, вызывающиеся при появлении клавиатуры
final Map<String, VoidCallback> _showListeners = {};
/// Колбэки, вызывающиеся при сокрытии клавиатуры
final Map<String, VoidCallback> _hideListeners = {};
bool get isVisibleKeyboard =>
     WidgetsBinding.instance.window.viewInsets.bottom > 0;
KeyboardListener() {
   _init();
}
void dispose() {
   // Удаляем текущий класс из списка наблюдателей
   WidgetsBinding.instance.removeObserver(this);
   // Очищаем списки колбэков
   _changeListeners.clear();
   _showListeners.clear();
   _hideListeners.clear();
}
/// При изменениях системного UI вызываем слушателей
@override
void didChangeMetrics() {
   _listener();
}
/// Метод добавления слушателей
String addListener({
   String id,
   KeyboardChangeListener onChange,
   VoidCallback onShow,
   VoidCallback onHide,
}) {
   assert(onChange != null || onShow != null || onHide != null);
   /// Для более удобного доступа к слушателям используются идентификаторы
   id ??= _generateId();
   if (onChange != null) _changeListeners[id] = onChange;
   if (onShow != null) _showListeners[id] = onShow;
   if (onHide != null) _hideListeners[id] = onHide;
   return id;
}
/// Методы удаления слушателей
void removeChangeListener(KeyboardChangeListener listener) {
   _removeListener(_changeListeners, listener);
}
void removeShowListener(VoidCallback listener) {
   _removeListener(_showListeners, listener);
}
void removeHideListener(VoidCallback listener) {
   _removeListener(_hideListeners, listener);
}
void removeAtChangeListener(String id) {
   _removeAtListener(_changeListeners, id);
}
void removeAtShowListener(String id) {
   _removeAtListener(_changeListeners, id);
}
void removeAtHideListener(String id) {
   _removeAtListener(_changeListeners, id);
}
void _removeAtListener(Map<String, Function> listeners, String id) {
   listeners.remove(id);
}
void _removeListener(Map<String, Function> listeners, Function listener) {
   listeners.removeWhere((key, value) => value == listener);
}
String _generateId() {
   return _random.nextDouble().toString();
}
void _init() {
   WidgetsBinding.instance.addObserver(this); // Регистрируем наблюдателя
}
void _listener() {
   if (isVisibleKeyboard) {
     _onShow();
     _onChange(true);
   } else {
     _onHide();
     _onChange(false);
   }
}
void _onChange(bool isOpen) {
   for (KeyboardChangeListener listener in _changeListeners.values) {
     listener(isOpen);
   }
}
void _onShow() {
   for (VoidCallback listener in _showListeners.values) {
     listener();
   }
}
void _onHide() {
   for (VoidCallback listener in _hideListeners.values) {
     listener();
   }
}
}