Added support for iOS keyboard appearance (#230)

packages/zefyr/example/lib/src/full_page.dart

             focusNode: _focusNode,
             mode: _editing ? ZefyrMode.edit : ZefyrMode.select,
             imageDelegate: CustomImageDelegate(),
+            keyboardAppearance: Brightness.dark,
           ),
         ),
       ),

packages/zefyr/lib/src/widgets/editable_text.dart

     this.mode = ZefyrMode.edit,
     this.padding = const EdgeInsets.symmetric(horizontal: 16.0),
     this.physics,
+    this.keyboardAppearance = Brightness.light,
   })  : assert(mode != null),
         assert(controller != null),
         assert(focusNode != null),
+        assert(keyboardAppearance != null),
         super(key: key);
 
   /// Controls the document being edited.
   /// Padding around editable area.
   final EdgeInsets padding;
 
+  /// The appearance of the keyboard.
+  ///
+  /// This setting is only honored on iOS devices.
+  ///
+  /// If unset, defaults to the brightness of [Brightness.light].
+  final Brightness keyboardAppearance;
+
   @override
   _ZefyrEditableTextState createState() => _ZefyrEditableTextState();
 }
   /// keyboard become visible.
   void requestKeyboard() {
     if (_focusNode.hasFocus) {
-      _input.openConnection(widget.controller.plainTextEditingValue);
+      _input.openConnection(
+          widget.controller.plainTextEditingValue, widget.keyboardAppearance);
     } else {
       FocusScope.of(context).requestFocus(_focusNode);
     }
   }
 
   void _handleFocusChange() {
-    _input.openOrCloseConnection(
-        _focusNode, widget.controller.plainTextEditingValue);
+    _input.openOrCloseConnection(_focusNode,
+        widget.controller.plainTextEditingValue, widget.keyboardAppearance);
     _cursorTimer.startOrStop(_focusNode, selection);
     updateKeepAlive();
   }

packages/zefyr/lib/src/widgets/editor.dart

     this.imageDelegate,
     this.selectionControls,
     this.physics,
+    this.keyboardAppearance,
   })  : assert(mode != null),
         assert(controller != null),
         assert(focusNode != null),
   /// Padding around editable area.
   final EdgeInsets padding;
 
+  /// The appearance of the keyboard.
+  ///
+  /// This setting is only honored on iOS devices.
+  ///
+  /// If unset, defaults to the brightness of [ThemeData.primaryColorBrightness].
+  final Brightness keyboardAppearance;
+
   @override
   _ZefyrEditorState createState() => _ZefyrEditorState();
 }
 
   @override
   Widget build(BuildContext context) {
+    final ThemeData themeData = Theme.of(context);
+    final Brightness keyboardAppearance =
+        widget.keyboardAppearance ?? themeData.primaryColorBrightness;
+
     Widget editable = ZefyrEditableText(
       controller: _scope.controller,
       focusNode: _scope.focusNode,
       mode: widget.mode,
       padding: widget.padding,
       physics: widget.physics,
+      keyboardAppearance: keyboardAppearance,
     );
 
     return ZefyrTheme(

packages/zefyr/lib/src/widgets/field.dart

   final ZefyrImageDelegate imageDelegate;
   final ScrollPhysics physics;
 
+  /// The appearance of the keyboard.
+  ///
+  /// This setting is only honored on iOS devices.
+  ///
+  /// If unset, defaults to the brightness of [ThemeData.primaryColorBrightness].
+  final Brightness keyboardAppearance;
+
   const ZefyrField({
     Key key,
     this.decoration,
     this.toolbarDelegate,
     this.imageDelegate,
     this.physics,
+    this.keyboardAppearance,
   }) : super(key: key);
 
   @override
       toolbarDelegate: widget.toolbarDelegate,
       imageDelegate: widget.imageDelegate,
       physics: widget.physics,
+      keyboardAppearance: widget.keyboardAppearance,
     );
 
     if (widget.height != null) {

packages/zefyr/lib/src/widgets/input.dart

 
   /// Opens or closes input connection based on the current state of
   /// [focusNode] and [value].
-  void openOrCloseConnection(FocusNode focusNode, TextEditingValue value) {
+  void openOrCloseConnection(FocusNode focusNode, TextEditingValue value,
+      Brightness keyboardAppearance) {
     if (focusNode.hasFocus && focusNode.consumeKeyboardToken()) {
-      openConnection(value);
+      openConnection(value, keyboardAppearance);
     } else if (!focusNode.hasFocus) {
       closeConnection();
     }
   }
 
-  void openConnection(TextEditingValue value) {
+  void openConnection(TextEditingValue value, Brightness keyboardAppearance) {
     if (!hasConnection) {
       _lastKnownRemoteTextEditingValue = value;
       _textInputConnection = TextInput.attach(
           obscureText: false,
           autocorrect: true,
           inputAction: TextInputAction.newline,
+          keyboardAppearance: keyboardAppearance,
           textCapitalization: TextCapitalization.sentences,
         ),
       )..setEditingState(value);