@kaleem766/react-native-incoming-call 0.1.0

package/nitrogen/generated/ios/swift/HybridIncomingCallSpec_cxx.swift

@@ -0,0 +1,270 @@
+///
+/// HybridIncomingCallSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridIncomingCallSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridIncomingCallSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::incomingcall::bridge::swift`)
+   * from `IncomingCall-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.incomingcall.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridIncomingCallSpec` Swift protocol.
+   */
+  private var __implementation: any HybridIncomingCallSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridIncomingCallSpec_
+
+  /**
+   * Create a new `HybridIncomingCallSpec_cxx` that wraps the given `HybridIncomingCallSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridIncomingCallSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridIncomingCallSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridIncomingCallSpec() -> any HybridIncomingCallSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridIncomingCallSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridIncomingCallSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridIncomingCallSpec_cxx {
+    return Unmanaged<HybridIncomingCallSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridIncomingCallSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridIncomingCallSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridIncomingCallSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridIncomingCallSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Compares this object with the given [other] object for reference equality.
+   */
+  @inline(__always)
+  public func equals(other: HybridIncomingCallSpec_cxx) -> Bool {
+    return self.__implementation === other.__implementation
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  public final var color: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.color)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.color = String(newValue)
+    }
+  }
+  
+  public final var callerName: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.callerName {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.callerName = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var avatar: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.avatar {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.avatar = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var callType: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.callType {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.callType = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var timeout: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.timeout {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.timeout = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+
+  // Methods
+  @inline(__always)
+  public final func answerCall() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.answerCall()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func rejectCall() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.rejectCall()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  public final func getView() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(__implementation.view).toOpaque()
+  }
+  
+  public final func beforeUpdate() {
+    __implementation.beforeUpdate()
+  }
+  
+  public final func afterUpdate() {
+    __implementation.afterUpdate()
+  }
+  
+  public final func maybePrepareForRecycle() {
+    guard let recyclable = __implementation as? any RecyclableView else { return }
+    recyclable.prepareForRecycle()
+  }
+}

package/nitrogen/generated/shared/c++/HybridIncomingCallSpec.cpp

@@ -0,0 +1,32 @@
+///
+/// HybridIncomingCallSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridIncomingCallSpec.hpp"
+
+namespace margelo::nitro::incomingcall {
+
+  void HybridIncomingCallSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("color", &HybridIncomingCallSpec::getColor);
+      prototype.registerHybridSetter("color", &HybridIncomingCallSpec::setColor);
+      prototype.registerHybridGetter("callerName", &HybridIncomingCallSpec::getCallerName);
+      prototype.registerHybridSetter("callerName", &HybridIncomingCallSpec::setCallerName);
+      prototype.registerHybridGetter("avatar", &HybridIncomingCallSpec::getAvatar);
+      prototype.registerHybridSetter("avatar", &HybridIncomingCallSpec::setAvatar);
+      prototype.registerHybridGetter("callType", &HybridIncomingCallSpec::getCallType);
+      prototype.registerHybridSetter("callType", &HybridIncomingCallSpec::setCallType);
+      prototype.registerHybridGetter("timeout", &HybridIncomingCallSpec::getTimeout);
+      prototype.registerHybridSetter("timeout", &HybridIncomingCallSpec::setTimeout);
+      prototype.registerHybridMethod("answerCall", &HybridIncomingCallSpec::answerCall);
+      prototype.registerHybridMethod("rejectCall", &HybridIncomingCallSpec::rejectCall);
+    });
+  }
+
+} // namespace margelo::nitro::incomingcall

package/nitrogen/generated/shared/c++/HybridIncomingCallSpec.hpp

@@ -0,0 +1,73 @@
+///
+/// HybridIncomingCallSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::incomingcall {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `IncomingCall`
+   * Inherit this class to create instances of `HybridIncomingCallSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridIncomingCall: public HybridIncomingCallSpec {
+   * public:
+   *   HybridIncomingCall(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridIncomingCallSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridIncomingCallSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridIncomingCallSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getColor() = 0;
+      virtual void setColor(const std::string& color) = 0;
+      virtual std::optional<std::string> getCallerName() = 0;
+      virtual void setCallerName(const std::optional<std::string>& callerName) = 0;
+      virtual std::optional<std::string> getAvatar() = 0;
+      virtual void setAvatar(const std::optional<std::string>& avatar) = 0;
+      virtual std::optional<std::string> getCallType() = 0;
+      virtual void setCallType(const std::optional<std::string>& callType) = 0;
+      virtual std::optional<double> getTimeout() = 0;
+      virtual void setTimeout(std::optional<double> timeout) = 0;
+
+    public:
+      // Methods
+      virtual void answerCall() = 0;
+      virtual void rejectCall() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "IncomingCall";
+  };
+
+} // namespace margelo::nitro::incomingcall

package/nitrogen/generated/shared/c++/views/HybridIncomingCallComponent.cpp

@@ -0,0 +1,127 @@
+///
+/// HybridIncomingCallComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridIncomingCallComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <NitroModules/PropNameIDCache.hpp>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+namespace margelo::nitro::incomingcall::views {
+
+  extern const char HybridIncomingCallComponentName[] = "IncomingCall";
+
+  HybridIncomingCallProps::HybridIncomingCallProps(const react::PropsParserContext& context,
+                                                   const HybridIncomingCallProps& sourceProps,
+                                                   const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    color([&]() -> CachedProp<std::string> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("color", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.color;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.color);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("IncomingCall.color: ") + exc.what());
+      }
+    }()),
+    callerName([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("callerName", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.callerName;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.callerName);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("IncomingCall.callerName: ") + exc.what());
+      }
+    }()),
+    avatar([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("avatar", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.avatar;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.avatar);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("IncomingCall.avatar: ") + exc.what());
+      }
+    }()),
+    callType([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("callType", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.callType;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.callType);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("IncomingCall.callType: ") + exc.what());
+      }
+    }()),
+    timeout([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("timeout", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.timeout;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.timeout);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("IncomingCall.timeout: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridIncomingCallSpec>& /* ref */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.hybridRef;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridIncomingCallSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f")), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("IncomingCall.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  bool HybridIncomingCallProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("color"): return true;
+      case hashString("callerName"): return true;
+      case hashString("avatar"): return true;
+      case hashString("callType"): return true;
+      case hashString("timeout"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridIncomingCallComponentDescriptor::HybridIncomingCallComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridIncomingCallComponentDescriptor::cloneProps(const react::PropsParserContext& context,
+                                                                                        const std::shared_ptr<const react::Props>& props,
+                                                                                        react::RawProps rawProps) const {
+    // 1. Prepare raw props parser
+    rawProps.parse(rawPropsParser_);
+    // 2. Copy props with Nitro's cached copy constructor
+    return HybridIncomingCallShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridIncomingCallComponentDescriptor::adopt(react::ShadowNode& shadowNode) const {
+    // This is called immediately after `ShadowNode` is created, cloned or in progress.
+    // On Android, we need to wrap props in our state, which gets routed through Java and later unwrapped in JNI/C++.
+    auto& concreteShadowNode = static_cast<HybridIncomingCallShadowNode&>(shadowNode);
+    const std::shared_ptr<const HybridIncomingCallProps>& constProps = concreteShadowNode.getConcreteSharedProps();
+    const std::shared_ptr<HybridIncomingCallProps>& props = std::const_pointer_cast<HybridIncomingCallProps>(constProps);
+    HybridIncomingCallState state{props};
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::incomingcall::views

package/nitrogen/generated/shared/c++/views/HybridIncomingCallComponent.hpp

@@ -0,0 +1,115 @@
+///
+/// HybridIncomingCallComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <string>
+#include <optional>
+#include <memory>
+#include "HybridIncomingCallSpec.hpp"
+#include <functional>
+
+namespace margelo::nitro::incomingcall::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridIncomingCallComponentName[];
+
+  /**
+   * Props for the "IncomingCall" View.
+   */
+  class HybridIncomingCallProps final: public react::ViewProps {
+  public:
+    HybridIncomingCallProps() = default;
+    HybridIncomingCallProps(const react::PropsParserContext& context,
+                            const HybridIncomingCallProps& sourceProps,
+                            const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::string> color;
+    CachedProp<std::optional<std::string>> callerName;
+    CachedProp<std::optional<std::string>> avatar;
+    CachedProp<std::optional<std::string>> callType;
+    CachedProp<std::optional<double>> timeout;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridIncomingCallSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "IncomingCall" View.
+   */
+  class HybridIncomingCallState final {
+  public:
+    HybridIncomingCallState() = default;
+    explicit HybridIncomingCallState(const std::shared_ptr<HybridIncomingCallProps>& props):
+      _props(props) {}
+
+  public:
+    [[nodiscard]]
+    const std::shared_ptr<HybridIncomingCallProps>& getProps() const {
+      return _props;
+    }
+
+  public:
+#ifdef ANDROID
+  HybridIncomingCallState(const HybridIncomingCallState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridIncomingCallState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridIncomingCallState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::shared_ptr<HybridIncomingCallProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "IncomingCall" View.
+   */
+  using HybridIncomingCallShadowNode = react::ConcreteViewShadowNode<HybridIncomingCallComponentName /* "HybridIncomingCall" */,
+                                                                     HybridIncomingCallProps /* custom props */,
+                                                                     react::ViewEventEmitter /* default */,
+                                                                     HybridIncomingCallState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "IncomingCall" View.
+   */
+  class HybridIncomingCallComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridIncomingCallShadowNode> {
+  public:
+    explicit HybridIncomingCallComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridIncomingCallProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "IncomingCall" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::incomingcall::views

package/nitrogen/generated/shared/json/IncomingCallConfig.json

@@ -0,0 +1,14 @@
+{
+  "uiViewClassName": "IncomingCall",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "color": true,
+    "callerName": true,
+    "avatar": true,
+    "callType": true,
+    "timeout": true,
+    "hybridRef": true
+  }
+}