"""Protocol for creating, updating, and managing children of a native view type."""

def create(self, props: Dict[str, Any]) -> Any:

raise NotImplementedError

def update(self, native_view: Any, changed_props: Dict[str, Any]) -> None:

raise NotImplementedError

def add_child(self, parent: Any, child: Any) -> None:

pass

def remove_child(self, parent: Any, child: Any) -> None:

pass

def insert_child(self, parent: Any, child: Any, index: int) -> None:

"""Maps element type names to platform-specific :class:`ViewHandler` instances."""

def __init__(self) -> None:

self._handlers: Dict[str, ViewHandler] = {}

def register(self, type_name: str, handler: ViewHandler) -> None:

self._handlers[type_name] = handler

def create_view(self, type_name: str, props: Dict[str, Any]) -> Any:

handler = self._handlers.get(type_name)

if handler is None:

raise ValueError(f"Unknown element type: {type_name!r}")

return handler.create(props)

def update_view(self, native_view: Any, type_name: str, changed_props: Dict[str, Any]) -> None:

handler = self._handlers.get(type_name)

if handler is not None:

handler.update(native_view, changed_props)

def add_child(self, parent: Any, child: Any, parent_type: str) -> None:

handler = self._handlers.get(parent_type)

if handler is not None:

handler.add_child(parent, child)

def remove_child(self, parent: Any, child: Any, parent_type: str) -> None:

handler = self._handlers.get(parent_type)

if handler is not None:

handler.remove_child(parent, child)

def insert_child(self, parent: Any, child: Any, parent_type: str, index: int) -> None:

handler = self._handlers.get(parent_type)

if handler is not None:

"""Parse ``#RRGGBB`` / ``#AARRGGBB`` hex string or raw int to a *signed* ARGB int.

if isinstance(color, int):

val = color

else:

c = color.strip().lstrip("#")

if len(c) == 6:

c = "FF" + c

val = int(c, 16)

if val > 0x7FFFFFFF:

val -= 0x100000000

padding: Any,

) -> tuple:

"""Normalise various padding representations to ``(left, top, right, bottom)``."""

if padding is None:

return (0, 0, 0, 0)

if isinstance(padding, (int, float)):

v = int(padding)

return (v, v, v, v)

if isinstance(padding, dict):

h = int(padding.get("horizontal", 0))

v = int(padding.get("vertical", 0))

left = int(padding.get("left", h))

right = int(padding.get("right", h))

top = int(padding.get("top", v))

bottom = int(padding.get("bottom", v))

a = int(padding.get("all", 0))

if a:

left = left or a

right = right or a

top = top or a

bottom = bottom or a

return (left, top, right, bottom)

from java import dynamic_proxy, jclass

from .utils import get_android_context

def _ctx() -> Any:

return get_android_context()

def _density() -> float:

return float(_ctx().getResources().getDisplayMetrics().density)

def _dp(value: float) -> int:

return int(value * _density())

# ---- Text -----------------------------------------------------------

class AndroidTextHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

tv = jclass("android.widget.TextView")(_ctx())

self._apply(tv, props)

return tv

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, tv: Any, props: Dict[str, Any]) -> None:

if "text" in props:

tv.setText(str(props["text"]))

if "font_size" in props and props["font_size"] is not None:

tv.setTextSize(float(props["font_size"]))

if "color" in props and props["color"] is not None:

tv.setTextColor(parse_color_int(props["color"]))

if "background_color" in props and props["background_color"] is not None:

tv.setBackgroundColor(parse_color_int(props["background_color"]))

if "bold" in props and props["bold"]:

tv.setTypeface(tv.getTypeface(), 1) # Typeface.BOLD = 1

if "max_lines" in props and props["max_lines"] is not None:

tv.setMaxLines(int(props["max_lines"]))

if "text_align" in props:

Gravity = jclass("android.view.Gravity")

mapping = {"left": Gravity.START, "center": Gravity.CENTER, "right": Gravity.END}

tv.setGravity(mapping.get(props["text_align"], Gravity.START))

# ---- Button ---------------------------------------------------------

class AndroidButtonHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

btn = jclass("android.widget.Button")(_ctx())

self._apply(btn, props)

return btn

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, btn: Any, props: Dict[str, Any]) -> None:

if "title" in props:

btn.setText(str(props["title"]))

if "font_size" in props and props["font_size"] is not None:

btn.setTextSize(float(props["font_size"]))

if "color" in props and props["color"] is not None:

btn.setTextColor(parse_color_int(props["color"]))

if "background_color" in props and props["background_color"] is not None:

btn.setBackgroundColor(parse_color_int(props["background_color"]))

if "enabled" in props:

btn.setEnabled(bool(props["enabled"]))

if "on_click" in props:

cb = props["on_click"]

if cb is not None:

class ClickProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):

def __init__(self, callback: Callable[[], None]) -> None:

super().__init__()

self.callback = callback

def onClick(self, view: Any) -> None:

self.callback()

btn.setOnClickListener(ClickProxy(cb))

else:

btn.setOnClickListener(None)

# ---- Column (vertical LinearLayout) ---------------------------------

class AndroidColumnHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

ll = jclass("android.widget.LinearLayout")(_ctx())

ll.setOrientation(jclass("android.widget.LinearLayout").VERTICAL)

self._apply(ll, props)

return ll

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, ll: Any, props: Dict[str, Any]) -> None:

if "spacing" in props and props["spacing"]:

px = _dp(float(props["spacing"]))

GradientDrawable = jclass("android.graphics.drawable.GradientDrawable")

d = GradientDrawable()

d.setColor(0x00000000)

d.setSize(1, px)

ll.setShowDividers(jclass("android.widget.LinearLayout").SHOW_DIVIDER_MIDDLE)

ll.setDividerDrawable(d)

if "padding" in props:

left, top, right, bottom = _resolve_padding(props["padding"])

ll.setPadding(_dp(left), _dp(top), _dp(right), _dp(bottom))

if "alignment" in props and props["alignment"]:

Gravity = jclass("android.view.Gravity")

mapping = {

"fill": Gravity.FILL_HORIZONTAL,

"center": Gravity.CENTER_HORIZONTAL,

"leading": Gravity.START,

"start": Gravity.START,

"trailing": Gravity.END,

"end": Gravity.END,

}

ll.setGravity(mapping.get(props["alignment"], Gravity.FILL_HORIZONTAL))

if "background_color" in props and props["background_color"] is not None:

ll.setBackgroundColor(parse_color_int(props["background_color"]))

def add_child(self, parent: Any, child: Any) -> None:

parent.addView(child)

def remove_child(self, parent: Any, child: Any) -> None:

parent.removeView(child)

def insert_child(self, parent: Any, child: Any, index: int) -> None:

parent.addView(child, index)

# ---- Row (horizontal LinearLayout) ----------------------------------

class AndroidRowHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

ll = jclass("android.widget.LinearLayout")(_ctx())

ll.setOrientation(jclass("android.widget.LinearLayout").HORIZONTAL)

self._apply(ll, props)

return ll

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, ll: Any, props: Dict[str, Any]) -> None:

if "spacing" in props and props["spacing"]:

px = _dp(float(props["spacing"]))

GradientDrawable = jclass("android.graphics.drawable.GradientDrawable")

d = GradientDrawable()

d.setColor(0x00000000)

d.setSize(px, 1)

ll.setShowDividers(jclass("android.widget.LinearLayout").SHOW_DIVIDER_MIDDLE)

ll.setDividerDrawable(d)

if "padding" in props:

left, top, right, bottom = _resolve_padding(props["padding"])

ll.setPadding(_dp(left), _dp(top), _dp(right), _dp(bottom))

if "alignment" in props and props["alignment"]:

Gravity = jclass("android.view.Gravity")

mapping = {

"fill": Gravity.FILL_VERTICAL,

"center": Gravity.CENTER_VERTICAL,

"top": Gravity.TOP,

"bottom": Gravity.BOTTOM,

}

ll.setGravity(mapping.get(props["alignment"], Gravity.FILL_VERTICAL))

if "background_color" in props and props["background_color"] is not None:

ll.setBackgroundColor(parse_color_int(props["background_color"]))

def add_child(self, parent: Any, child: Any) -> None:

parent.addView(child)

def remove_child(self, parent: Any, child: Any) -> None:

parent.removeView(child)

def insert_child(self, parent: Any, child: Any, index: int) -> None:

parent.addView(child, index)

# ---- ScrollView -----------------------------------------------------

class AndroidScrollViewHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

sv = jclass("android.widget.ScrollView")(_ctx())

if "background_color" in props and props["background_color"] is not None:

sv.setBackgroundColor(parse_color_int(props["background_color"]))

return sv

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

if "background_color" in changed and changed["background_color"] is not None:

native_view.setBackgroundColor(parse_color_int(changed["background_color"]))

def add_child(self, parent: Any, child: Any) -> None:

parent.addView(child)

def remove_child(self, parent: Any, child: Any) -> None:

parent.removeView(child)

# ---- TextInput (EditText) -------------------------------------------

class AndroidTextInputHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

et = jclass("android.widget.EditText")(_ctx())

self._apply(et, props)

return et

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, et: Any, props: Dict[str, Any]) -> None:

if "value" in props:

et.setText(str(props["value"]))

if "placeholder" in props:

et.setHint(str(props["placeholder"]))

if "font_size" in props and props["font_size"] is not None:

et.setTextSize(float(props["font_size"]))

if "color" in props and props["color"] is not None:

et.setTextColor(parse_color_int(props["color"]))

if "background_color" in props and props["background_color"] is not None:

et.setBackgroundColor(parse_color_int(props["background_color"]))

if "secure" in props and props["secure"]:

InputType = jclass("android.text.InputType")

et.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD)

# ---- Image ----------------------------------------------------------

class AndroidImageHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

iv = jclass("android.widget.ImageView")(_ctx())

self._apply(iv, props)

return iv

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, iv: Any, props: Dict[str, Any]) -> None:

if "background_color" in props and props["background_color"] is not None:

iv.setBackgroundColor(parse_color_int(props["background_color"]))

# ---- Switch ---------------------------------------------------------

class AndroidSwitchHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

sw = jclass("android.widget.Switch")(_ctx())

self._apply(sw, props)

return sw

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, sw: Any, props: Dict[str, Any]) -> None:

if "value" in props:

sw.setChecked(bool(props["value"]))

if "on_change" in props and props["on_change"] is not None:

cb = props["on_change"]

class CheckedProxy(dynamic_proxy(jclass("android.widget.CompoundButton").OnCheckedChangeListener)):

def __init__(self, callback: Callable[[bool], None]) -> None:

super().__init__()

self.callback = callback

def onCheckedChanged(self, button: Any, checked: bool) -> None:

self.callback(checked)

sw.setOnCheckedChangeListener(CheckedProxy(cb))

# ---- ProgressBar ----------------------------------------------------

class AndroidProgressBarHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

style = jclass("android.R$attr").progressBarStyleHorizontal

pb = jclass("android.widget.ProgressBar")(_ctx(), None, 0, style)

pb.setMax(1000)

self._apply(pb, props)

return pb

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, pb: Any, props: Dict[str, Any]) -> None:

if "value" in props:

pb.setProgress(int(float(props["value"]) * 1000))

# ---- ActivityIndicator (circular ProgressBar) -----------------------

class AndroidActivityIndicatorHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

pb = jclass("android.widget.ProgressBar")(_ctx())

if not props.get("animating", True):

pb.setVisibility(jclass("android.view.View").GONE)

return pb

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

View = jclass("android.view.View")

if "animating" in changed:

native_view.setVisibility(View.VISIBLE if changed["animating"] else View.GONE)

# ---- WebView --------------------------------------------------------

class AndroidWebViewHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

wv = jclass("android.webkit.WebView")(_ctx())

if "url" in props and props["url"]:

wv.loadUrl(str(props["url"]))

return wv

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

if "url" in changed and changed["url"]:

native_view.loadUrl(str(changed["url"]))

# ---- Spacer ---------------------------------------------------------

class AndroidSpacerHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

v = jclass("android.view.View")(_ctx())

if "size" in props and props["size"] is not None:

px = _dp(float(props["size"]))

lp = jclass("android.widget.LinearLayout$LayoutParams")(px, px)

v.setLayoutParams(lp)

return v

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

if "size" in changed and changed["size"] is not None:

px = _dp(float(changed["size"]))

lp = jclass("android.widget.LinearLayout$LayoutParams")(px, px)

native_view.setLayoutParams(lp)

registry.register("Text", AndroidTextHandler())

registry.register("Button", AndroidButtonHandler())

registry.register("Column", AndroidColumnHandler())

registry.register("Row", AndroidRowHandler())

registry.register("ScrollView", AndroidScrollViewHandler())

registry.register("TextInput", AndroidTextInputHandler())

registry.register("Image", AndroidImageHandler())

registry.register("Switch", AndroidSwitchHandler())

registry.register("ProgressBar", AndroidProgressBarHandler())

registry.register("ActivityIndicator", AndroidActivityIndicatorHandler())

registry.register("WebView", AndroidWebViewHandler())

from rubicon.objc import SEL, ObjCClass, objc_method

NSObject = ObjCClass("NSObject")

UIColor = ObjCClass("UIColor")

UIFont = ObjCClass("UIFont")

def _uicolor(color: Any) -> Any:

argb = parse_color_int(color)

if argb < 0:

argb += 0x100000000

a = ((argb >> 24) & 0xFF) / 255.0

r = ((argb >> 16) & 0xFF) / 255.0

g = ((argb >> 8) & 0xFF) / 255.0

b = (argb & 0xFF) / 255.0

return UIColor.colorWithRed_green_blue_alpha_(r, g, b, a)

# ---- Text -----------------------------------------------------------

class IOSTextHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

label = ObjCClass("UILabel").alloc().init()

self._apply(label, props)

return label

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, label: Any, props: Dict[str, Any]) -> None:

if "text" in props:

label.setText_(str(props["text"]))

if "font_size" in props and props["font_size"] is not None:

if props.get("bold"):

label.setFont_(UIFont.boldSystemFontOfSize_(float(props["font_size"])))

else:

label.setFont_(UIFont.systemFontOfSize_(float(props["font_size"])))

elif "bold" in props and props["bold"]:

size = label.font().pointSize() if label.font() else 17.0

label.setFont_(UIFont.boldSystemFontOfSize_(size))

if "color" in props and props["color"] is not None:

label.setTextColor_(_uicolor(props["color"]))

if "background_color" in props and props["background_color"] is not None:

label.setBackgroundColor_(_uicolor(props["background_color"]))

if "max_lines" in props and props["max_lines"] is not None:

label.setNumberOfLines_(int(props["max_lines"]))

if "text_align" in props:

mapping = {"left": 0, "center": 1, "right": 2}

label.setTextAlignment_(mapping.get(props["text_align"], 0))

# ---- Button ---------------------------------------------------------

# btn id(ObjCInstance) -> _PNButtonTarget. Keeps a strong ref to

# each handler (preventing GC) and lets us swap the callback on

# re-render without calling removeTarget/addTarget (which crashes

# due to rubicon-objc wrapper lifecycle issues).

_pn_btn_handler_map: dict = {}

class _PNButtonTarget(NSObject): # type: ignore[valid-type]

_callback: Optional[Callable[[], None]] = None

@objc_method

def onTap_(self, sender: object) -> None:

if self._callback is not None:

self._callback()

# Strong refs to retained UIButton wrappers so the ObjCInstance

# (and its prevent-deallocation retain) stays alive for the

# lifetime of the app.

_pn_retained_views: list = []

class IOSButtonHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

btn = ObjCClass("UIButton").alloc().init()

btn.retain()

_pn_retained_views.append(btn)

_ios_blue = UIColor.colorWithRed_green_blue_alpha_(0.0, 0.478, 1.0, 1.0)

btn.setTitleColor_forState_(_ios_blue, 0)

self._apply(btn, props)

return btn

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, btn: Any, props: Dict[str, Any]) -> None:

if "title" in props:

btn.setTitle_forState_(str(props["title"]), 0)

if "font_size" in props and props["font_size"] is not None:

btn.titleLabel().setFont_(UIFont.systemFontOfSize_(float(props["font_size"])))

if "background_color" in props and props["background_color"] is not None:

btn.setBackgroundColor_(_uicolor(props["background_color"]))

if "color" not in props:

_white = UIColor.colorWithRed_green_blue_alpha_(1.0, 1.0, 1.0, 1.0)

btn.setTitleColor_forState_(_white, 0)

if "color" in props and props["color"] is not None:

btn.setTitleColor_forState_(_uicolor(props["color"]), 0)

if "enabled" in props:

btn.setEnabled_(bool(props["enabled"]))

if "on_click" in props:

existing = _pn_btn_handler_map.get(id(btn))

if existing is not None:

existing._callback = props["on_click"]

else:

handler = _PNButtonTarget.new()

handler._callback = props["on_click"]

_pn_btn_handler_map[id(btn)] = handler

btn.addTarget_action_forControlEvents_(handler, SEL("onTap:"), 1 << 6)

# ---- Column (vertical UIStackView) ----------------------------------

class IOSColumnHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

sv = ObjCClass("UIStackView").alloc().initWithFrame_(((0, 0), (0, 0)))

sv.setAxis_(1) # vertical

self._apply(sv, props)

return sv

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, sv: Any, props: Dict[str, Any]) -> None:

if "spacing" in props and props["spacing"]:

sv.setSpacing_(float(props["spacing"]))

if "alignment" in props and props["alignment"]:

mapping = {"fill": 0, "leading": 1, "top": 1, "center": 3, "trailing": 4, "bottom": 4}

sv.setAlignment_(mapping.get(props["alignment"], 0))

if "background_color" in props and props["background_color"] is not None:

sv.setBackgroundColor_(_uicolor(props["background_color"]))

if "padding" in props:

left, top, right, bottom = _resolve_padding(props["padding"])

sv.setLayoutMarginsRelativeArrangement_(True)

try:

sv.setDirectionalLayoutMargins_((top, left, bottom, right))

except Exception:

sv.setLayoutMargins_((top, left, bottom, right))

def add_child(self, parent: Any, child: Any) -> None:

parent.addArrangedSubview_(child)

def remove_child(self, parent: Any, child: Any) -> None:

parent.removeArrangedSubview_(child)

child.removeFromSuperview()

def insert_child(self, parent: Any, child: Any, index: int) -> None:

parent.insertArrangedSubview_atIndex_(child, index)

# ---- Row (horizontal UIStackView) -----------------------------------

class IOSRowHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

sv = ObjCClass("UIStackView").alloc().initWithFrame_(((0, 0), (0, 0)))

sv.setAxis_(0) # horizontal

self._apply(sv, props)

return sv

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, sv: Any, props: Dict[str, Any]) -> None:

if "spacing" in props and props["spacing"]:

sv.setSpacing_(float(props["spacing"]))

if "alignment" in props and props["alignment"]:

mapping = {"fill": 0, "leading": 1, "top": 1, "center": 3, "trailing": 4, "bottom": 4}

sv.setAlignment_(mapping.get(props["alignment"], 0))

if "background_color" in props and props["background_color"] is not None:

sv.setBackgroundColor_(_uicolor(props["background_color"]))

def add_child(self, parent: Any, child: Any) -> None:

parent.addArrangedSubview_(child)

def remove_child(self, parent: Any, child: Any) -> None:

parent.removeArrangedSubview_(child)

child.removeFromSuperview()

def insert_child(self, parent: Any, child: Any, index: int) -> None:

parent.insertArrangedSubview_atIndex_(child, index)

# ---- ScrollView -----------------------------------------------------

class IOSScrollViewHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

sv = ObjCClass("UIScrollView").alloc().init()

if "background_color" in props and props["background_color"] is not None:

sv.setBackgroundColor_(_uicolor(props["background_color"]))

return sv

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

if "background_color" in changed and changed["background_color"] is not None:

native_view.setBackgroundColor_(_uicolor(changed["background_color"]))

def add_child(self, parent: Any, child: Any) -> None:

child.setTranslatesAutoresizingMaskIntoConstraints_(False)

parent.addSubview_(child)

content_guide = parent.contentLayoutGuide

frame_guide = parent.frameLayoutGuide

child.topAnchor.constraintEqualToAnchor_(content_guide.topAnchor).setActive_(True)

child.leadingAnchor.constraintEqualToAnchor_(content_guide.leadingAnchor).setActive_(True)

child.trailingAnchor.constraintEqualToAnchor_(content_guide.trailingAnchor).setActive_(True)

child.bottomAnchor.constraintEqualToAnchor_(content_guide.bottomAnchor).setActive_(True)

child.widthAnchor.constraintEqualToAnchor_(frame_guide.widthAnchor).setActive_(True)

def remove_child(self, parent: Any, child: Any) -> None:

child.removeFromSuperview()

# ---- TextInput (UITextField) ----------------------------------------

class IOSTextInputHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

tf = ObjCClass("UITextField").alloc().init()

tf.setBorderStyle_(2) # RoundedRect

self._apply(tf, props)

return tf

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, tf: Any, props: Dict[str, Any]) -> None:

if "value" in props:

tf.setText_(str(props["value"]))

if "placeholder" in props:

tf.setPlaceholder_(str(props["placeholder"]))

if "font_size" in props and props["font_size"] is not None:

tf.setFont_(UIFont.systemFontOfSize_(float(props["font_size"])))

if "color" in props and props["color"] is not None:

tf.setTextColor_(_uicolor(props["color"]))

if "background_color" in props and props["background_color"] is not None:

tf.setBackgroundColor_(_uicolor(props["background_color"]))

if "secure" in props and props["secure"]:

tf.setSecureTextEntry_(True)

# ---- Image ----------------------------------------------------------

class IOSImageHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

iv = ObjCClass("UIImageView").alloc().init()

if "background_color" in props and props["background_color"] is not None:

iv.setBackgroundColor_(_uicolor(props["background_color"]))

return iv

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

if "background_color" in changed and changed["background_color"] is not None:

native_view.setBackgroundColor_(_uicolor(changed["background_color"]))

# ---- Switch ---------------------------------------------------------

class IOSSwitchHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

sw = ObjCClass("UISwitch").alloc().init()

self._apply(sw, props)

return sw

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

self._apply(native_view, changed)

def _apply(self, sw: Any, props: Dict[str, Any]) -> None:

if "value" in props:

sw.setOn_animated_(bool(props["value"]), False)

# ---- ProgressBar (UIProgressView) -----------------------------------

class IOSProgressBarHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

pv = ObjCClass("UIProgressView").alloc().init()

if "value" in props:

pv.setProgress_(float(props["value"]))

return pv

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

if "value" in changed:

native_view.setProgress_(float(changed["value"]))

# ---- ActivityIndicator ----------------------------------------------

class IOSActivityIndicatorHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

ai = ObjCClass("UIActivityIndicatorView").alloc().init()

if props.get("animating", True):

ai.startAnimating()

return ai

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

if "animating" in changed:

if changed["animating"]:

native_view.startAnimating()

else:

native_view.stopAnimating()

# ---- WebView (WKWebView) --------------------------------------------

class IOSWebViewHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

wv = ObjCClass("WKWebView").alloc().init()

if "url" in props and props["url"]:

NSURL = ObjCClass("NSURL")

NSURLRequest = ObjCClass("NSURLRequest")

url_obj = NSURL.URLWithString_(str(props["url"]))

wv.loadRequest_(NSURLRequest.requestWithURL_(url_obj))

return wv

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

if "url" in changed and changed["url"]:

NSURL = ObjCClass("NSURL")

NSURLRequest = ObjCClass("NSURLRequest")

url_obj = NSURL.URLWithString_(str(changed["url"]))

native_view.loadRequest_(NSURLRequest.requestWithURL_(url_obj))

# ---- Spacer ---------------------------------------------------------

class IOSSpacerHandler(ViewHandler):

def create(self, props: Dict[str, Any]) -> Any:

v = ObjCClass("UIView").alloc().init()

if "size" in props and props["size"] is not None:

size = float(props["size"])

v.setFrame_(((0, 0), (size, size)))

return v

def update(self, native_view: Any, changed: Dict[str, Any]) -> None:

if "size" in changed and changed["size"] is not None:

size = float(changed["size"])

native_view.setFrame_(((0, 0), (size, size)))

registry.register("Text", IOSTextHandler())

registry.register("Button", IOSButtonHandler())

registry.register("Column", IOSColumnHandler())

registry.register("Row", IOSRowHandler())

registry.register("ScrollView", IOSScrollViewHandler())

registry.register("TextInput", IOSTextInputHandler())

registry.register("Image", IOSImageHandler())

registry.register("Switch", IOSSwitchHandler())

registry.register("ProgressBar", IOSProgressBarHandler())

registry.register("ActivityIndicator", IOSActivityIndicatorHandler())

registry.register("WebView", IOSWebViewHandler())

"""Return the singleton registry, lazily creating platform handlers."""

global _registry

if _registry is not None:

return _registry

_registry = NativeViewRegistry()

if IS_ANDROID:

_register_android_handlers(_registry)

else:

_register_ios_handlers(_registry)