{  
  "package_name": "com.companyname.appname"  
}

/// This is the entry view controller to the keyboard
/// this file can be copied as such by any client, the only thing
/// that would change is the name of the class (ex:KeyboardVC)

import UIKit
import Keemoji

class KeyboardViewController: UIInputViewController {
    let keyboardExtensionSDK = KeyboardExtensionSDK()
    
    override func viewDidLoad() {
      super.viewDidLoad()

      /// Any client integrating the SDK, would have to initialize the customization module
      /// prior to first use
      KeyboardExtensionSDK.setup(customizable: KBCustomization())
      keyboardExtensionSDK.inputViewController = self
    }
    
    override func viewWillAppear(_ animated: Bool) {
      super.viewWillAppear(animated)
      /// Any client integrating the SDK, would have to
      /// call the extension implementation from the SDK
      keyboardExtensionSDK.controllerViewWillAppear(animated)
    }
    
    override func viewDidAppear(_ animated: Bool) {
      super.viewDidAppear(animated)
      /// Any client integrating the SDK, would have to
      /// call the extension implementation from the SDK
      keyboardExtensionSDK.controllerViewDidAppear(animated)
    }
    
    override func viewWillDisappear(_ animated: Bool) {
      super.viewWillDisappear(animated)
      /// Any client integrating the SDK, would have to
      /// call the extension implementation from the SDK
      keyboardExtensionSDK.controllerViewWillDisappear(animated)
    }
    
    override func viewDidDisappear(_ animated: Bool) {
      super.viewDidDisappear(animated)
      /// Any client integrating the SDK, would have to
      /// call the extension implementation from the SDK
      keyboardExtensionSDK.controllerViewDidDisappear(animated)
    }
    
    override func viewWillLayoutSubviews() {
      super.viewWillLayoutSubviews()
      /// Any client integrating the SDK, would have to
      /// call the extension implementation from the SDK
      keyboardExtensionSDK.controllerViewWillLayoutSubviews()
    }
    
    override func viewWillTransition(
      to size: CGSize,
      with coordinator: UIViewControllerTransitionCoordinator
    ) {
      super.viewWillTransition(to: size, with: coordinator)
      /// Any client integrating the SDK, would have to
      /// call the extension implementation from the SDK
      keyboardExtensionSDK.controllerViewWillTransition(to: size, with: coordinator)
    }
    
    override func textDidChange(_ textInput: UITextInput?) {
      /// Any client integrating the SDK, would have to
      /// call the extension implementation from the SDK
      keyboardExtensionSDK.controllerTextDidChange(textInput)
    }

  }

<key>NSExtensionPrincipalClass</key>
<string>$(PRODUCT_MODULE_NAME).KeyboardVC</string>

import UIKit
import Keemoji

/// KBCustomization implementation of the KMCustomizable protocol
/// Any client integrating the SDK, would have to provide a similar implementation of this protocol
/// it is the main custom module containing the other customization objects
public struct KBCustomization: KeemojiCustomizable {
    /// computed property for Configurator protocol implementation
    public var localizer: KeemojiLocalizer
        
        /// computed property for ImageProvider protocol implementation
        public var imageProvider: KeemojiImageProvider
        
        /// computed property for ColorPalette protocol implementation
        public var colorPalette: KeemojiColorPalette
            
        /// Initializes the KBCustomization() module, to be passed by injection
        /// the properties are initialized with the module's implementations for
        /// the respective protocols
        public init() {
            localizer = KMLocalizer()
            imageProvider = KMImageProvider()
            colorPalette = KMColorPalette()
        }

    }

    public struct KMImageProvider: KeemojiImageProvider {
        /// Retrieves an image asset for a given `name`, if an image exists
        /// To be used for app and keyboard assets
        /// ```
        /// image(named: "flag")
        /// ```
        ///
        /// - Parameter name: the name of the image asset
        ///
        /// - Returns: image asset for a given `name`, if an image exists;
        /// nil if no image exists with that name.
        public func image(named name: String) -> UIImage? {
            UIImage(named: name,
                    in: .main,
                    compatibleWith: nil)
        }

        /// Retrieves an icon asset for a given `name`, if an icon exists
        /// To be used in the context of the toolbar (for iconresources)
        /// ```
        /// icon(named: "flag")
        /// ```
        ///
        /// - Parameter name: the name of the icon asset
        ///
        /// - Returns: icon asset for a given `name`, if an icon exists;
        /// nil if no icon exists with that name.
        public func icon(named name: String) -> UIImage? {
            UIImage(named: name,
                    in: .main,
                    compatibleWith: nil)
        }
    }

    public struct KMColorPalette: KeemojiColorPalette {
      /// computed property for status bar background
      /// in case client has forced per-app appearance
      ///
      /// - Returns: The keyboard text color
      public var activation_status_bg: UIColor { .black }

        public init() {}

    }

    public struct KMLocalizer: KeemojiLocalizer {
        /// Produces the translation for the given `text` into the desired language.
        ///
        /// ```
        /// translation("Download") // "Descargar"
        /// ```
        ///
        ///
        /// - Parameter text: The text to be translated.
        ///
        /// - Returns: translation for the given `text` into the desired language.
        public func translation(_ text: String) -> String {
            NSLocalizedString(text, comment: "")
        }

        public init() {}

    }

static const platform = MethodChannel('mocha.channel.shared.data');
...
isKeyboardInstalled() async {
    bool result = await platform.invokeMethod("isKeyboardInstalled");
    setState(() {
      isKeyboardInstalledStatus = result;
    });
 }

launchActivationIfNeeded() async {
    await platform.invokeMethod("launchActivationIfNeeded");
}

import Flutter
import Keemoji
...
@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {
...
    func application(
        _: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool
    {
        
			initKeyboard()
        
        let controller : FlutterViewController = window?.rootViewController as! FlutterViewController
        let methodChannel = FlutterMethodChannel(name: "mocha.channel.shared.data",
                                                binaryMessenger: controller.binaryMessenger)
        methodChannel.setMethodCallHandler({
            [weak self] (call: FlutterMethodCall, result: FlutterResult) -> Void in
            // This method is invoked on the UI thread.
            if call.method == "isKeyboardInstalled" {
                self?.isKeyboardInstalled(result: result)
            } else if call.method == "isKeyboardAdded" {
                self?.isKeyboardAdded(result: result)
            } else if call.method == "launchActivationIfNeeded" {
                self?.launchActivationIfNeeded(result: result)
            } else {
                result(FlutterMethodNotImplemented)
                return
            }
        })
// ...

	  }

	  private func initKeyboard() {
        observeOnboardingStatus()
        KeyboardSDK.setup(customizable: KBCustomization())
        KeyboardSDK.initialize()
    }

/// Any client integrating the SDK would have to subscribe to the SDK isOnboardingFinished publisher
    /// and go to the next step of the app flow (after finishing onboarding)
    private func observeOnboardingStatus() {
        KeyboardSDK.onboardingStatus.$isOnboardingFinished
            .receive(on: DispatchQueue.main)
            .sink { finished in
                // do something
            }
            .store(in: &cancellables)
	   // optional, if Onboarding can be cancelled (flag is true)     
        KeyboardSDK.onboardingStatus.$isOnboardingDismissed
            .receive(on: DispatchQueue.main)
            .sink { dismissed in
                // do something
            }
            .store(in: &cancellables)
    }

	  private func launchActivationIfNeeded(result: FlutterResult) {
        startOnboarding()
    }
    
    private func startOnboarding() {
        if rootController == nil {
          rootController = UIApplication.shared.windows[0].rootViewController
        }
        KeyboardSDK.startOnboarding()
    }

    override func application(_ app: UIApplication,
                 open url: URL,
                 options: [UIApplication.OpenURLOptionsKey : Any] = [:]
    ) -> Bool {
        // needed at least for the SDK launch Settings feature,
        // other deep links behaviour needs to be implemented in the app
        if url.absoluteString.contains("title=launchSettings") {
            return KeyboardSDK.application(open: url, options: options)
        }
        return super.application(app, open: url, options: options)
    }