"""Platform-level metrics shared between screen hosts and view handlers.

The screen host (`pythonnative.screen`) is the only place that knows

about native window/safe-area state because it is the only piece of

code that holds a reference to the native ``UIViewController``

(iOS) or ``Activity`` (Android). Native view handlers, however, need

that state to size themselves correctly:

- A bottom tab bar must claim both its visible 49 pt / 56 dp content

height **and** the bottom safe-area inset so its background reaches

the edge of the screen and the home indicator / gesture bar does

not draw on top of the labels.

- A future safe-area-aware container can read the same values instead

of asking each native view for window metrics.

Rather than threading those values through every

[`measure_intrinsic`][pythonnative.native_views.base.ViewHandler.measure_intrinsic]

call signature, the screen host writes them here and handlers read

them on demand. Values are in **dp on Android** and **pt on iOS** —

i.e., the same "layout units" the layout engine uses on each

platform, so handlers can add them to other layout-unit values

without further conversion. On iOS the screen host consumes the top

safe-area inset by positioning the root view below it, then publishes

``top=0`` here; Android publishes the raw system-bar insets because

the host view normally remains full-screen.

Example:

>>> from pythonnative.platform_metrics import (

... get_safe_area_insets, set_safe_area_insets,

... )

>>> set_safe_area_insets(top=44.0, left=0.0, bottom=34.0, right=0.0)

>>> get_safe_area_insets().bottom

34.0

"""

from __future__ import annotations

import threading

from typing import Callable, List, NamedTuple

class SafeAreaInsets(NamedTuple):

"""Safe-area insets in layout units (pt on iOS, dp on Android)."""

top: float

left: float

bottom: float

right: float

class WindowDimensions(NamedTuple):

"""Viewport size in layout units (pt on iOS, dp on Android)."""

width: float

height: float

_safe_area_insets: SafeAreaInsets = SafeAreaInsets(0.0, 0.0, 0.0, 0.0)

_window_dimensions: WindowDimensions = WindowDimensions(0.0, 0.0)

_keyboard_height: float = 0.0

_subscribers: List[Callable[[], None]] = []

_subscribers_lock = threading.Lock()

def _notify_subscribers() -> None:

"""Invoke every registered subscriber, swallowing exceptions.

Called from every metric setter so subscriber callbacks (the React

hooks ``use_window_dimensions``/``use_safe_area_insets``/

``use_keyboard_height`` for example) can re-render in response to

any metric change. Subscribers are called serially in registration

order; any callback that raises is logged-and-skipped so a single

misbehaving subscriber can't take down the whole notification

cycle.

"""

with _subscribers_lock:

callbacks = list(_subscribers)

for cb in callbacks:

try:

cb()

except Exception:

pass

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

"""Register *callback* to fire whenever any metric changes.

Returns an unsubscribe function. Hooks pass a state setter so a

component re-renders whenever the platform reports a new value.

Threadsafe — multiple subscribers may register/unregister

concurrently.

"""

with _subscribers_lock:

_subscribers.append(callback)

def _unsub() -> None:

with _subscribers_lock:

try:

_subscribers.remove(callback)

except ValueError:

pass

return _unsub

def set_safe_area_insets(top: float, left: float, bottom: float, right: float) -> None:

"""Publish the current safe-area insets.

Called by the platform-specific screen host whenever it learns a

new value (e.g., on first layout, on rotation, on multitasking

split-view changes). Negative inputs are clamped to ``0.0`` so

handlers don't have to defend against bad data from native

callers.

Args:

top: Distance in layout units from the top of the host

container to the safe area (status bar / dynamic island /

navigation bar).

left: Inset from the left edge.

bottom: Inset from the bottom edge (home indicator / gesture

bar).

right: Inset from the right edge.

"""

global _safe_area_insets

new_insets = SafeAreaInsets(

max(0.0, float(top)),

max(0.0, float(left)),

max(0.0, float(bottom)),

max(0.0, float(right)),

)

if new_insets == _safe_area_insets:

return

_safe_area_insets = new_insets

_notify_subscribers()

def get_safe_area_insets() -> SafeAreaInsets:

"""Return the current safe-area insets.

The default value is ``(0, 0, 0, 0)`` — handlers should still

function correctly on a desktop / unit-test environment where no

screen host has published insets.

"""

return _safe_area_insets

def reset_safe_area_insets() -> None:

"""Reset the insets back to ``(0, 0, 0, 0)``.

Intended for unit tests that need a clean slate between cases.

Production code should use

[`set_safe_area_insets`][pythonnative.platform_metrics.set_safe_area_insets]

instead.

"""

global _safe_area_insets

_safe_area_insets = SafeAreaInsets(0.0, 0.0, 0.0, 0.0)

def set_window_dimensions(width: float, height: float) -> None:

"""Publish the viewport size in layout units.

Called by the screen host on initial layout, rotation, and split-

view changes. Notifies subscribers (and therefore re-renders

components using ``use_window_dimensions``) only when the size

actually changes.

"""

global _window_dimensions

new_dims = WindowDimensions(max(0.0, float(width)), max(0.0, float(height)))

if new_dims == _window_dimensions:

return

_window_dimensions = new_dims

_notify_subscribers()

def get_window_dimensions() -> WindowDimensions:

"""Return the current viewport size, or ``(0, 0)`` before first layout."""

return _window_dimensions

def reset_window_dimensions() -> None:

"""Reset window dimensions back to ``(0, 0)``. Intended for tests."""

global _window_dimensions

_window_dimensions = WindowDimensions(0.0, 0.0)

def set_keyboard_height(height: float) -> None:

"""Publish the on-screen keyboard height in layout units.

Negative inputs are clamped to ``0.0``. Notifies subscribers only

when the value actually changes.

"""

global _keyboard_height

new_h = max(0.0, float(height))

if new_h == _keyboard_height:

return

_keyboard_height = new_h

_notify_subscribers()

def get_keyboard_height() -> float:

"""Return the current on-screen keyboard height, or ``0.0`` if hidden."""

return _keyboard_height

def reset_keyboard_height() -> None:

"""Reset the keyboard height back to ``0.0``. Intended for tests."""

global _keyboard_height

_keyboard_height = 0.0

# ======================================================================

# Per-platform tab-bar defaults

# ======================================================================

#

# Only iOS exposes an explicit constant here. The iOS handler can't

# trust ``UITabBar.sizeThatFits_`` (it has historically returned 0 in

# some configurations) and the screen host deliberately extends the

# root view past the bottom safe area so the bar reaches the home

# indicator — both pieces conspire to require a single source of

# truth for the height formula.

#

# Android intentionally has no equivalent: ``BottomNavigationView``

# reports a reliable natural height via ``measure(…)`` once attached

# to the window, and the active-indicator pill is positioned against

# that natural height. Forcing our own height threw off the pill

# geometry, so the Android handler defers entirely to the system.

#: UIKit HIG tab-bar content height in points. The total bar reaches

#: ``IOS_TAB_BAR_BASE_HEIGHT_PT + safe_area_insets.bottom`` so the

#: pill background can extend over the home indicator. Apple's HIG

#: places the tab bar flush with the screen edge and lets UIKit

#: render its own internal padding for the home indicator.

IOS_TAB_BAR_BASE_HEIGHT_PT: float = 49.0

def ios_tab_bar_height() -> float:

"""Return the iOS tab-bar intrinsic height in points.

Equal to ``IOS_TAB_BAR_BASE_HEIGHT_PT + safe_area_insets.bottom``

so the bar reaches the home indicator. The iOS screen host

deliberately extends the root view past the bottom safe area for

this very reason — the tab bar absorbs the inset and UIKit

renders the pill with internal padding for the home indicator.

Used by ``pythonnative.native_views.ios.TabBarHandler``; exposed

here so the formula is testable without importing the iOS

handler module (which requires ``rubicon-objc``).

"""

return IOS_TAB_BAR_BASE_HEIGHT_PT + get_safe_area_insets().bottom