@matiks/rn-app-state 1.0.0

package/nitrogen/generated/android/c++/JAppStateChangeEvent.hpp

@@ -0,0 +1,57 @@
+///
+/// JAppStateChangeEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AppStateChangeEvent.hpp"
+
+#include <string>
+
+namespace margelo::nitro::appstate {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AppStateChangeEvent" and the the Kotlin data class "AppStateChangeEvent".
+   */
+  struct JAppStateChangeEvent final: public jni::JavaClass<JAppStateChangeEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/appstate/AppStateChangeEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AppStateChangeEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AppStateChangeEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldState = clazz->getField<jni::JString>("state");
+      jni::local_ref<jni::JString> state = this->getFieldValue(fieldState);
+      return AppStateChangeEvent(
+        state->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JAppStateChangeEvent::javaobject> fromCpp(const AppStateChangeEvent& value) {
+      using JSignature = JAppStateChangeEvent(jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.state)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::appstate

package/nitrogen/generated/android/c++/JAppStateListener.hpp

@@ -0,0 +1,67 @@
+///
+/// JAppStateListener.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AppStateListener.hpp"
+
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include <functional>
+
+namespace margelo::nitro::appstate {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AppStateListener" and the the Kotlin data class "AppStateListener".
+   */
+  struct JAppStateListener final: public jni::JavaClass<JAppStateListener> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/appstate/AppStateListener;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AppStateListener by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AppStateListener toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldRemove = clazz->getField<JFunc_void::javaobject>("remove");
+      jni::local_ref<JFunc_void::javaobject> remove = this->getFieldValue(fieldRemove);
+      return AppStateListener(
+        [&]() -> std::function<void()> {
+          if (remove->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(remove);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto removeRef = jni::make_global(remove);
+            return JNICallable<JFunc_void, void()>(std::move(removeRef));
+          }
+        }()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JAppStateListener::javaobject> fromCpp(const AppStateListener& value) {
+      using JSignature = JAppStateListener(jni::alias_ref<JFunc_void::javaobject>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JFunc_void_cxx::fromCpp(value.remove)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::appstate

package/nitrogen/generated/android/c++/JFunc_void.hpp

@@ -0,0 +1,75 @@
+///
+/// JFunc_void.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::appstate {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/appstate/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/appstate/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::appstate

package/nitrogen/generated/android/c++/JFunc_void_AppStateChangeEvent.hpp

@@ -0,0 +1,78 @@
+///
+/// JFunc_void_AppStateChangeEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "AppStateChangeEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JAppStateChangeEvent.hpp"
+#include <string>
+
+namespace margelo::nitro::appstate {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: AppStateChangeEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_AppStateChangeEvent: public jni::JavaClass<JFunc_void_AppStateChangeEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/appstate/Func_void_AppStateChangeEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_AppStateChangeEvent` instance holds through JNI.
+     */
+    void invoke(const AppStateChangeEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JAppStateChangeEvent> /* event */)>("invoke");
+      method(self(), JAppStateChangeEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_AppStateChangeEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_AppStateChangeEvent_cxx final: public jni::HybridClass<JFunc_void_AppStateChangeEvent_cxx, JFunc_void_AppStateChangeEvent> {
+  public:
+    static jni::local_ref<JFunc_void_AppStateChangeEvent::javaobject> fromCpp(const std::function<void(const AppStateChangeEvent& /* event */)>& func) {
+      return JFunc_void_AppStateChangeEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_AppStateChangeEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JAppStateChangeEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const AppStateChangeEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/appstate/Func_void_AppStateChangeEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_AppStateChangeEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_AppStateChangeEvent_cxx(const std::function<void(const AppStateChangeEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const AppStateChangeEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::appstate

package/nitrogen/generated/android/c++/JHybridAppStateModuleSpec.cpp

@@ -0,0 +1,84 @@
+///
+/// JHybridAppStateModuleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridAppStateModuleSpec.hpp"
+
+// Forward declaration of `AppStateListener` to properly resolve imports.
+namespace margelo::nitro::appstate { struct AppStateListener; }
+// Forward declaration of `AppStateChangeEvent` to properly resolve imports.
+namespace margelo::nitro::appstate { struct AppStateChangeEvent; }
+
+#include <string>
+#include "AppStateListener.hpp"
+#include "JAppStateListener.hpp"
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "AppStateChangeEvent.hpp"
+#include "JFunc_void_AppStateChangeEvent.hpp"
+#include "JAppStateChangeEvent.hpp"
+
+namespace margelo::nitro::appstate {
+
+  jni::local_ref<JHybridAppStateModuleSpec::jhybriddata> JHybridAppStateModuleSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridAppStateModuleSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridAppStateModuleSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridAppStateModuleSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  bool JHybridAppStateModuleSpec::equals(const std::shared_ptr<HybridObject>& other) {
+    if (auto otherCast = std::dynamic_pointer_cast<JHybridAppStateModuleSpec>(other)) {
+      return _javaPart == otherCast->_javaPart;
+    }
+    return false;
+  }
+
+  void JHybridAppStateModuleSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridAppStateModuleSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  bool JHybridAppStateModuleSpec::getWasKilledLastSession() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getWasKilledLastSession");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+
+  // Methods
+  std::string JHybridAppStateModuleSpec::getCurrentState() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getCurrentState");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  AppStateListener JHybridAppStateModuleSpec::addListener(const std::function<void(const AppStateChangeEvent& /* event */)>& onStateChange) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JAppStateListener>(jni::alias_ref<JFunc_void_AppStateChangeEvent::javaobject> /* onStateChange */)>("addListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_AppStateChangeEvent_cxx::fromCpp(onStateChange));
+    return __result->toCpp();
+  }
+  std::string JHybridAppStateModuleSpec::getStateOnNotification() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getStateOnNotification");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+
+} // namespace margelo::nitro::appstate

package/nitrogen/generated/android/c++/JHybridAppStateModuleSpec.hpp

@@ -0,0 +1,68 @@
+///
+/// HybridAppStateModuleSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridAppStateModuleSpec.hpp"
+
+
+
+
+namespace margelo::nitro::appstate {
+
+  using namespace facebook;
+
+  class JHybridAppStateModuleSpec: public jni::HybridClass<JHybridAppStateModuleSpec, JHybridObject>,
+                                   public virtual HybridAppStateModuleSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/appstate/HybridAppStateModuleSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridAppStateModuleSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridAppStateModuleSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridAppStateModuleSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    bool equals(const std::shared_ptr<HybridObject>& other) override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridAppStateModuleSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    bool getWasKilledLastSession() override;
+
+  public:
+    // Methods
+    std::string getCurrentState() override;
+    AppStateListener addListener(const std::function<void(const AppStateChangeEvent& /* event */)>& onStateChange) override;
+    std::string getStateOnNotification() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridAppStateModuleSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::appstate

package/nitrogen/generated/android/kotlin/com/margelo/nitro/appstate/AppStateChangeEvent.kt

@@ -0,0 +1,38 @@
+///
+/// AppStateChangeEvent.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.appstate
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "AppStateChangeEvent".
+ */
+@DoNotStrip
+@Keep
+data class AppStateChangeEvent(
+  @DoNotStrip
+  @Keep
+  val state: String
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(state: String): AppStateChangeEvent {
+      return AppStateChangeEvent(state)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/appstate/AppStateListener.kt

@@ -0,0 +1,42 @@
+///
+/// AppStateListener.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.appstate
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "AppStateListener".
+ */
+@DoNotStrip
+@Keep
+data class AppStateListener(
+  @DoNotStrip
+  @Keep
+  val remove: Func_void
+) {
+  /**
+   * Create a new instance of AppStateListener from Kotlin
+   */
+  constructor(remove: () -> Unit):
+         this(Func_void_java(remove))
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(remove: Func_void): AppStateListener {
+      return AppStateListener(remove)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/appstate/Func_void.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.appstate
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `() => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void: () -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(): Unit
+}
+
+/**
+ * Represents the JavaScript callback `() => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_cxx: Func_void {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(): Unit
+    = invoke_cxx()
+
+  @FastNative
+  private external fun invoke_cxx(): Unit
+}
+
+/**
+ * Represents the JavaScript callback `() => void`.
+ * This is implemented in Java/Kotlin, via a `() -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_java(private val function: () -> Unit): Func_void {
+  @DoNotStrip
+  @Keep
+  override fun invoke(): Unit {
+    return this.function()
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/appstate/Func_void_AppStateChangeEvent.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_AppStateChangeEvent.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.appstate
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(event: struct) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_AppStateChangeEvent: (AppStateChangeEvent) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(event: AppStateChangeEvent): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(event: struct) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_AppStateChangeEvent_cxx: Func_void_AppStateChangeEvent {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(event: AppStateChangeEvent): Unit
+    = invoke_cxx(event)
+
+  @FastNative
+  private external fun invoke_cxx(event: AppStateChangeEvent): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(event: struct) => void`.
+ * This is implemented in Java/Kotlin, via a `(AppStateChangeEvent) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_AppStateChangeEvent_java(private val function: (AppStateChangeEvent) -> Unit): Func_void_AppStateChangeEvent {
+  @DoNotStrip
+  @Keep
+  override fun invoke(event: AppStateChangeEvent): Unit {
+    return this.function(event)
+  }
+}