Android-pyApi/android_pyapi/android/util.py

"""
Android Util 组件 — Log, SparseArray, LruCache, DisplayMetrics 等
方法签名完全对齐 Android SDK
"""

import math
import re as _re
import struct
import sys
from datetime import datetime
from typing import Any, Callable, Dict, Generic, List, Optional, Set, Tuple, TypeVar, Union

from .._core import (
    Stub, AndroidOnlyError, android_context,
    resolve_android_path, to_android_path,
    _sdcard_root, _app_data_dir,
)


# ═══════════════════════════════════════════════════════════════
# Log
# ═══════════════════════════════════════════════════════════════

class Log(Stub):
    """Log — 日志输出"""

    ASSERT = 7
    DEBUG = 3
    ERROR = 6
    INFO = 4
    VERBOSE = 2
    WARN = 5

    _min_log_level = VERBOSE

    @staticmethod
    def v(tag: str, msg: str) -> int:
        if Log._min_log_level <= Log.VERBOSE:
            sys.stderr.write(f"V/{tag}: {msg}\n")
        return 0

    @staticmethod
    def d(tag: str, msg: str) -> int:
        if Log._min_log_level <= Log.DEBUG:
            sys.stderr.write(f"D/{tag}: {msg}\n")
        return 0

    @staticmethod
    def i(tag: str, msg: str) -> int:
        if Log._min_log_level <= Log.INFO:
            sys.stderr.write(f"I/{tag}: {msg}\n")
        return 0

    @staticmethod
    def w(tag: str, msg: str = None, tr: Exception = None) -> int:
        if Log._min_log_level <= Log.WARN:
            # 支持 w(tag, Throwable) 调用形式
            if msg is None and tr is not None:
                msg = Log.getStackTraceString(tr)
            elif tr is not None:
                msg = f"{msg}\n{Log.getStackTraceString(tr)}"
            sys.stderr.write(f"W/{tag}: {msg}\n")
        return 0

    @staticmethod
    def e(tag: str, msg: str = None, tr: Exception = None) -> int:
        if Log._min_log_level <= Log.ERROR:
            # 支持 e(tag, Throwable) 调用形式
            if msg is None and tr is not None:
                msg = Log.getStackTraceString(tr)
            elif tr is not None:
                msg = f"{msg}\n{Log.getStackTraceString(tr)}"
            sys.stderr.write(f"E/{tag}: {msg}\n")
        return 0

    @staticmethod
    def wtf(tag: str, msg=None, tr: Exception = None) -> int:
        """What a Terrible Failure。支持以下调用形式：
        - wtf(tag, msg)
        - wtf(tag, Throwable)
        - wtf(tag, msg, Throwable)
        """
        # 如果 msg 是异常对象，则当作 tr 处理
        if isinstance(msg, BaseException):
            tr = msg
            msg = None
        if msg is None and tr is not None:
            msg = Log.getStackTraceString(tr)
        elif tr is not None:
            msg = f"{msg}\n{Log.getStackTraceString(tr)}"
        if msg is None:
            msg = ""
        sys.stderr.write(f"WTF/{tag}: {msg}\n")
        return 0

    @staticmethod
    def println(log_level: int, tag: str, msg: str) -> int:
        level_map = {
            Log.VERBOSE: "V",
            Log.DEBUG: "D",
            Log.INFO: "I",
            Log.WARN: "W",
            Log.ERROR: "E",
            Log.ASSERT: "A",
        }
        prefix = level_map.get(log_level, "?")
        sys.stderr.write(f"{prefix}/{tag}: {msg}\n")
        return 0

    @staticmethod
    def isLoggable(tag: str, level: int) -> bool:
        return level >= Log._min_log_level

    @staticmethod
    def getStackTraceString(tr: Exception) -> str:
        import traceback
        if tr is None:
            return ""
        if isinstance(tr, str):
            return tr
        return "".join(traceback.format_exception(type(tr), tr, tr.__traceback__))

    @staticmethod
    def setMinLogLevel(level: int):
        Log._min_log_level = level


# ═══════════════════════════════════════════════════════════════
# SparseArray
# ═══════════════════════════════════════════════════════════════

T = TypeVar("T")

class SparseArray(Generic[T], Stub):
    """SparseArray — 稀疏数组（int 键映射）"""

    def __init__(self, initial_capacity: int = 10):
        super().__init__()
        self._keys: List[int] = []
        self._values: List[Optional[T]] = []
        self._size = 0

    def put(self, key: int, value: T):
        """如果 key 已存在则替换"""
        try:
            idx = self._keys.index(key)
            self._values[idx] = value
        except ValueError:
            self._keys.append(key)
            self._values.append(value)
            self._size += 1

    def get(self, key: int, default: Optional[T] = None) -> Optional[T]:
        try:
            idx = self._keys.index(key)
            return self._values[idx]
        except ValueError:
            return default

    def delete(self, key: int):
        try:
            idx = self._keys.index(key)
            self._keys.pop(idx)
            self._values.pop(idx)
            self._size -= 1
        except ValueError:
            pass

    def remove(self, key: int):
        self.delete(key)

    def removeAt(self, index: int):
        if 0 <= index < self._size:
            self._keys.pop(index)
            self._values.pop(index)
            self._size -= 1

    def size(self) -> int:
        return self._size

    def keyAt(self, index: int) -> int:
        if 0 <= index < self._size:
            return self._keys[index]
        return 0

    def valueAt(self, index: int) -> Optional[T]:
        if 0 <= index < self._size:
            return self._values[index]
        return None

    def setValueAt(self, index: int, value: T):
        if 0 <= index < self._size:
            self._values[index] = value

    def indexOfKey(self, key: int) -> int:
        try:
            return self._keys.index(key)
        except ValueError:
            return -1

    def indexOfValue(self, value: T) -> int:
        try:
            return self._values.index(value)
        except ValueError:
            return -1

    def clear(self):
        self._keys.clear()
        self._values.clear()
        self._size = 0

    def append(self, key: int, value: T):
        self.put(key, value)

    def containsKey(self, key: int) -> bool:
        return key in self._keys

    def putAll(self, other: "SparseArray[T]"):
        for i in range(other.size()):
            self.put(other.keyAt(i), other.valueAt(i))

    def clone(self) -> "SparseArray[T]":
        sa = SparseArray[T]()
        sa._keys = list(self._keys)
        sa._values = list(self._values)
        sa._size = self._size
        return sa

    def toString(self) -> str:
        pairs = ", ".join(
            f"{k}={v}" for k, v in zip(self._keys, self._values)
        )
        return f"SparseArray{{{pairs}}}"

    def __getitem__(self, key: int) -> Optional[T]:
        return self.get(key)

    def __setitem__(self, key: int, value: T):
        self.put(key, value)

    def __delitem__(self, key: int):
        self.delete(key)

    def __len__(self) -> int:
        return self._size

    def __contains__(self, key: int) -> bool:
        return key in self._keys


class SparseIntArray(Stub):
    """SparseIntArray — int 到 int 的映射"""

    def __init__(self, initial_capacity: int = 10):
        super().__init__()
        self._keys: List[int] = []
        self._values: List[int] = []

    def put(self, key: int, value: int):
        try:
            idx = self._keys.index(key)
            self._values[idx] = value
        except ValueError:
            self._keys.append(key)
            self._values.append(value)

    def get(self, key: int, default: int = 0) -> int:
        try:
            idx = self._keys.index(key)
            return self._values[idx]
        except ValueError:
            return default

    def delete(self, key: int):
        try:
            idx = self._keys.index(key)
            self._keys.pop(idx)
            self._values.pop(idx)
        except ValueError:
            pass

    def removeAt(self, index: int):
        if 0 <= index < len(self._keys):
            self._keys.pop(index)
            self._values.pop(index)

    def size(self) -> int:
        return len(self._keys)

    def keyAt(self, index: int) -> int:
        if 0 <= index < len(self._keys):
            return self._keys[index]
        return 0

    def valueAt(self, index: int) -> int:
        if 0 <= index < len(self._values):
            return self._values[index]
        return 0

    def indexOfKey(self, key: int) -> int:
        try:
            return self._keys.index(key)
        except ValueError:
            return -1

    def indexOfValue(self, value: int) -> int:
        try:
            return self._values.index(value)
        except ValueError:
            return -1

    def clear(self):
        self._keys.clear()
        self._values.clear()

    def append(self, key: int, value: int):
        self.put(key, value)

    def toString(self) -> str:
        pairs = ", ".join(f"{k}={v}" for k, v in zip(self._keys, self._values))
        return f"SparseIntArray{{{pairs}}}"


class SparseBooleanArray(Stub):
    """SparseBooleanArray — int 到 bool 的映射"""

    def __init__(self, initial_capacity: int = 10):
        super().__init__()
        self._keys: List[int] = []
        self._values: List[bool] = []

    def put(self, key: int, value: bool):
        try:
            idx = self._keys.index(key)
            self._values[idx] = value
        except ValueError:
            self._keys.append(key)
            self._values.append(value)

    def get(self, key: int, default: bool = False) -> bool:
        try:
            idx = self._keys.index(key)
            return self._values[idx]
        except ValueError:
            return default

    def delete(self, key: int):
        try:
            idx = self._keys.index(key)
            self._keys.pop(idx)
            self._values.pop(idx)
        except ValueError:
            pass

    def size(self) -> int:
        return len(self._keys)

    def keyAt(self, index: int) -> int:
        if 0 <= index < len(self._keys):
            return self._keys[index]
        return 0

    def valueAt(self, index: int) -> bool:
        if 0 <= index < len(self._values):
            return self._values[index]
        return False

    def indexOfKey(self, key: int) -> int:
        try:
            return self._keys.index(key)
        except ValueError:
            return -1

    def indexOfValue(self, value: bool) -> int:
        try:
            return self._values.index(value)
        except ValueError:
            return -1

    def clear(self):
        self._keys.clear()
        self._values.clear()

    def append(self, key: int, value: bool):
        self.put(key, value)

    def toString(self) -> str:
        pairs = ", ".join(f"{k}={v}" for k, v in zip(self._keys, self._values))
        return f"SparseBooleanArray{{{pairs}}}"


# ═══════════════════════════════════════════════════════════════
# LruCache
# ═══════════════════════════════════════════════════════════════

class LruCache(Stub):
    """LruCache — LRU 缓存"""

    def __init__(self, max_size: int):
        super().__init__()
        self._max_size = max_size
        self._size = 0
        self._map: Dict[Any, Any] = {}

    def get(self, key: Any) -> Optional[Any]:
        return self._map.get(key)

    def put(self, key: Any, value: Any) -> Optional[Any]:
        old = self._map.get(key)
        self._map[key] = value
        self._size += self._safe_size_of(key, value)
        if old is not None:
            self._size -= self._safe_size_of(key, old)
        self._trim_to_size(self._max_size)
        return old

    def remove(self, key: Any) -> Optional[Any]:
        value = self._map.pop(key, None)
        if value is not None:
            self._size -= self._safe_size_of(key, value)
        return value

    def size(self) -> int:
        return self._size

    def maxSize(self) -> int:
        return self._max_size

    def trimToSize(self, max_size: int):
        self._trim_to_size(max_size)

    def _trim_to_size(self, max_size: int):
        while self._size > max_size and self._map:
            # Remove oldest (first key)
            oldest_key = next(iter(self._map))
            self.remove(oldest_key)

    def snapshot(self) -> Dict[Any, Any]:
        return dict(self._map)

    def evictAll(self):
        self._map.clear()
        self._size = 0

    def _safe_size_of(self, key: Any, value: Any) -> int:
        try:
            return self.sizeOf(key, value)
        except Exception:
            return 1

    def sizeOf(self, key: Any, value: Any) -> int:
        return 1

    def entryRemoved(self, evicted: bool, key: Any, old_value: Any, new_value: Optional[Any]):
        pass

    def create(self, key: Any) -> Optional[Any]:
        return None

    def getCount(self) -> int:
        return len(self._map)

    def putCount(self) -> int:
        return len(self._map)

    def evictionCount(self) -> int:
        return 0

    def hitCount(self) -> int:
        return 0

    def missCount(self) -> int:
        return 0

    def toString(self) -> str:
        return f"LruCache(maxSize={self._max_size}, size={self._size})"


# ═══════════════════════════════════════════════════════════════
# DisplayMetrics
# ═══════════════════════════════════════════════════════════════

class DisplayMetrics(Stub):
    """DisplayMetrics — 屏幕显示度量"""

    DENSITY_LOW = 120
    DENSITY_MEDIUM = 160
    DENSITY_TV = 213
    DENSITY_HIGH = 240
    DENSITY_XHIGH = 320
    DENSITY_XXHIGH = 480
    DENSITY_XXXHIGH = 640
    DENSITY_DEFAULT = DENSITY_MEDIUM
    DENSITY_DEVICE_STABLE = DENSITY_XXXHIGH

    def __init__(self):
        super().__init__()
        self.widthPixels = 1080
        self.heightPixels = 1920
        self.density = 2.75
        self.densityDpi = 440
        self.scaledDensity = 2.75
        self.xdpi = 440.0
        self.ydpi = 440.0
        self.noncompatWidthPixels = 1080
        self.noncompatHeightPixels = 1920
        self.noncompatDensity = 2.75
        self.noncompatDensityDpi = 440
        self.noncompatScaledDensity = 2.75
        self.noncompatXdpi = 440.0
        self.noncompatYdpi = 440.0

    def setTo(self, other: "DisplayMetrics"):
        self.widthPixels = other.widthPixels
        self.heightPixels = other.heightPixels
        self.density = other.density
        self.densityDpi = other.densityDpi
        self.scaledDensity = other.scaledDensity
        self.xdpi = other.xdpi
        self.ydpi = other.ydpi

    def setToDefaults(self):
        self.__init__()

    def toString(self) -> str:
        return (f"DisplayMetrics({self.widthPixels}x{self.heightPixels}, "
                f"density={self.density}, dpi={self.densityDpi})")


# ═══════════════════════════════════════════════════════════════
# TypedValue
# ═══════════════════════════════════════════════════════════════

class TypedValue(Stub):
    """TypedValue — 类型化值的容器"""

    COMPLEX_UNIT_PX = 0
    COMPLEX_UNIT_DIP = 1
    COMPLEX_UNIT_SP = 2
    COMPLEX_UNIT_PT = 3
    COMPLEX_UNIT_IN = 4
    COMPLEX_UNIT_MM = 5
    COMPLEX_UNIT_FRACTION = 6
    COMPLEX_UNIT_FRACTION_PARENT = 7

    COMPLEX_UNIT_SHIFT = 0
    COMPLEX_UNIT_MASK = 0xF

    COMPLEX_RADIX_SHIFT = 4
    COMPLEX_RADIX_MASK = 0x3

    COMPLEX_MANTISSA_SHIFT = 8
    COMPLEX_MANTISSA_MASK = 0x00ffffff

    # 复数值的基数乘数（与 AOSP TypedValue.RADIX_MULTS 一致）
    _RADIX_MULTS = (
        0.00390625,       # 1/256,    radix 0
        3.0517578e-5,     # 1/32768,  radix 1
        1.1920929e-7,     # 1/8388608, radix 2
        4.6566129e-10,    # 1/2147483648, radix 3
    )

    TYPE_NULL = 0x00
    TYPE_REFERENCE = 0x01
    TYPE_ATTRIBUTE = 0x02
    TYPE_STRING = 0x03
    TYPE_FLOAT = 0x04
    TYPE_DIMENSION = 0x05
    TYPE_FRACTION = 0x06
    TYPE_FIRST_INT = 0x10
    TYPE_INT_DEC = 0x10
    TYPE_INT_HEX = 0x11
    TYPE_INT_BOOLEAN = 0x12
    TYPE_INT_COLOR_ARGB8 = 0x1C
    TYPE_INT_COLOR_RGB8 = 0x1D
    TYPE_INT_COLOR_ARGB4 = 0x1E
    TYPE_INT_COLOR_RGB4 = 0x1F
    TYPE_LAST_COLOR_INT = 0x1F
    TYPE_LAST_INT = 0x1F

    DATA_NULL_UNDEFINED = 0
    DATA_NULL_EMPTY = 1

    def __init__(self):
        super().__init__()
        self.type = self.TYPE_NULL
        self.data = 0
        self.assetCookie = 0
        self.resourceId = 0
        self.changingConfigurations = 0
        self.string = None
        self.density = 0

    @staticmethod
    def applyDimension(unit: int, value: float, metrics: DisplayMetrics) -> float:
        if unit == TypedValue.COMPLEX_UNIT_PX:
            return value
        if unit == TypedValue.COMPLEX_UNIT_DIP:
            return value * metrics.density
        if unit == TypedValue.COMPLEX_UNIT_SP:
            return value * metrics.scaledDensity
        if unit == TypedValue.COMPLEX_UNIT_PT:
            return value * metrics.xdpi * (1.0 / 72)
        if unit == TypedValue.COMPLEX_UNIT_IN:
            return value * metrics.xdpi
        if unit == TypedValue.COMPLEX_UNIT_MM:
            return value * metrics.xdpi * (1.0 / 25.4)
        return value

    @staticmethod
    def complexToDimension(data: int, metrics: DisplayMetrics) -> float:
        """将复数维度值转换为像素值。
        复数值格式：bits 0-3=unit, bits 4-5=radix, bits 8-31=mantissa(有符号24位)"""
        unit = (data >> TypedValue.COMPLEX_UNIT_SHIFT) & TypedValue.COMPLEX_UNIT_MASK
        radix = (data >> TypedValue.COMPLEX_RADIX_SHIFT) & TypedValue.COMPLEX_RADIX_MASK
        mantissa = (data >> TypedValue.COMPLEX_MANTISSA_SHIFT) & TypedValue.COMPLEX_MANTISSA_MASK
        # 24 位有符号数符号扩展
        if mantissa & 0x800000:
            mantissa = mantissa - 0x1000000
        value = mantissa * TypedValue._RADIX_MULTS[radix]
        return TypedValue.applyDimension(unit, value, metrics)

    @staticmethod
    def complexToFloat(data: int) -> float:
        """将复数值转换为浮点数（与 AOSP complexToFloat 一致）。"""
        radix = (data >> TypedValue.COMPLEX_RADIX_SHIFT) & TypedValue.COMPLEX_RADIX_MASK
        # mantissa 保持在原始位位置（左移 8 位），与 AOSP 一致
        mantissa = data & (TypedValue.COMPLEX_MANTISSA_MASK << TypedValue.COMPLEX_MANTISSA_SHIFT)
        # 处理符号（Java int 是有符号的，bit 31 为符号位）
        if mantissa & 0x80000000:
            mantissa = mantissa - 0x100000000
        return float(mantissa) * TypedValue._RADIX_MULTS[radix]

    @staticmethod
    def complexToDimensionPixelOffset(data: int, metrics: DisplayMetrics) -> int:
        return int(TypedValue.complexToDimension(data, metrics))

    @staticmethod
    def complexToDimensionPixelSize(data: int, metrics: DisplayMetrics) -> int:
        val = TypedValue.complexToDimension(data, metrics)
        if val >= 0:
            return int(val + 0.5)
        return int(val - 0.5)

    def getFloat(self) -> float:
        """将 data 字段按 IEEE 754 单精度浮点数解读（与 Float.intBitsToFloat 一致）。"""
        bits = self.data & 0xFFFFFFFF
        return struct.unpack('f', struct.pack('I', bits))[0]

    def toString(self) -> str:
        return f"TypedValue(type={self.type}, data={self.data})"


# ═══════════════════════════════════════════════════════════════
# Pair
# ═══════════════════════════════════════════════════════════════

class Pair(Stub):
    """Pair — 有序对"""

    def __init__(self, first: Any, second: Any):
        super().__init__()
        self.first = first
        self.second = second

    @staticmethod
    def create(a: Any, b: Any) -> "Pair":
        return Pair(a, b)

    def hashCode(self) -> int:
        return hash((self.first, self.second))

    def equals(self, other: Any) -> bool:
        if not isinstance(other, Pair):
            return False
        return self.first == other.first and self.second == other.second

    def toString(self) -> str:
        return f"Pair({self.first}, {self.second})"

    def __eq__(self, other):
        return self.equals(other)

    def __hash__(self):
        return self.hashCode()

    def __repr__(self):
        return self.toString()

    def __iter__(self):
        return iter((self.first, self.second))


# ═══════════════════════════════════════════════════════════════
# Size / SizeF
# ═══════════════════════════════════════════════════════════════

class Size(Stub):
    """Size — 整数尺寸"""

    def __init__(self, width: int, height: int):
        super().__init__()
        self._width = width
        self._height = height

    def getWidth(self) -> int:
        return self._width

    def getHeight(self) -> int:
        return self._height

    def equals(self, other: Any) -> bool:
        if not isinstance(other, Size):
            return False
        return self._width == other._width and self._height == other._height

    def hashCode(self) -> int:
        return (self._height << 16) ^ self._width

    def toString(self) -> str:
        return f"{self._width}x{self._height}"

    @staticmethod
    def parseSize(string: str) -> "Size":
        parts = string.split("x")
        if len(parts) == 2:
            return Size(int(parts[0]), int(parts[1]))
        raise ValueError(f"Invalid size: {string}")

    def __eq__(self, other):
        return self.equals(other)

    def __hash__(self):
        return self.hashCode()

    def __repr__(self):
        return self.toString()


class SizeF(Stub):
    """SizeF — 浮点数尺寸"""

    def __init__(self, width: float, height: float):
        super().__init__()
        self._width = width
        self._height = height

    def getWidth(self) -> float:
        return self._width

    def getHeight(self) -> float:
        return self._height

    def equals(self, other: Any) -> bool:
        if not isinstance(other, SizeF):
            return False
        return abs(self._width - other._width) < 0.001 and abs(self._height - other._height) < 0.001

    def hashCode(self) -> int:
        return hash((self._width, self._height))

    def toString(self) -> str:
        return f"{self._width:.1f}x{self._height:.1f}"

    @staticmethod
    def parseSizeF(string: str) -> "SizeF":
        parts = string.split("x")
        if len(parts) == 2:
            return SizeF(float(parts[0]), float(parts[1]))
        raise ValueError(f"Invalid size: {string}")

    def __eq__(self, other):
        return self.equals(other)

    def __hash__(self):
        return self.hashCode()

    def __repr__(self):
        return self.toString()


# ═══════════════════════════════════════════════════════════════
# StateSet
# ═══════════════════════════════════════════════════════════════

class StateSet(Stub):
    """StateSet — 状态集合"""

    VIEW_STATE_WINDOW_FOCUSED = 1
    VIEW_STATE_SELECTED = 1 << 1
    VIEW_STATE_FOCUSED = 1 << 2
    VIEW_STATE_ENABLED = 1 << 3
    VIEW_STATE_PRESSED = 1 << 4
    VIEW_STATE_ACTIVATED = 1 << 5
    VIEW_STATE_ACCELERATED = 1 << 6
    VIEW_STATE_HOVERED = 1 << 7
    VIEW_STATE_DRAG_CAN_ACCEPT = 1 << 8
    VIEW_STATE_DRAG_HOVERED = 1 << 9

    WILD_CARD = 0x00000000

    @staticmethod
    def isWildCard(state_spec_or_mask: Any) -> bool:
        if isinstance(state_spec_or_mask, list):
            return len(state_spec_or_mask) == 0
        return state_spec_or_mask == StateSet.WILD_CARD

    @staticmethod
    def trimStateSet(states: List[int], new_size: int) -> List[int]:
        return states[:new_size]

    @staticmethod
    def dump(states: List[int]) -> str:
        if not states:
            return "[]"
        return "[" + ", ".join(str(s) for s in states) + "]"


# ═══════════════════════════════════════════════════════════════
# MathUtils
# ═══════════════════════════════════════════════════════════════

class MathUtils(Stub):
    """MathUtils — 数学工具"""

    DEG_TO_RAD = math.pi / 180.0
    RAD_TO_DEG = 180.0 / math.pi

    @staticmethod
    def abs(v: float) -> float:
        return abs(v)

    @staticmethod
    def constrain(amount: float, low: float, high: float) -> float:
        return max(low, min(high, amount))

    @staticmethod
    def constrainInt(amount: int, low: int, high: int) -> int:
        return max(low, min(high, amount))

    @staticmethod
    def lerp(start: float, stop: float, amount: float) -> float:
        return start + (stop - start) * amount

    @staticmethod
    def lerpInv(a: float, b: float, value: float) -> float:
        if a != b:
            return (value - a) / (b - a)
        return 0.0

    @staticmethod
    def norm(start: float, stop: float, value: float) -> float:
        return MathUtils.lerpInv(start, stop, value)

    @staticmethod
    def map(min_start: float, min_stop: float, max_start: float, max_stop: float, value: float) -> float:
        return max_start + (value - min_start) * (max_stop - max_start) / (min_stop - min_start)

    @staticmethod
    def dist(x1: float, y1: float, x2: float, y2: float) -> float:
        return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

    @staticmethod
    def max(var1: float, var2: float) -> float:
        return max(var1, var2)

    @staticmethod
    def min(var1: float, var2: float) -> float:
        return min(var1, var2)

    @staticmethod
    def degrees(radians: float) -> float:
        return math.degrees(radians)

    @staticmethod
    def radians(degrees: float) -> float:
        return math.radians(degrees)

    @staticmethod
    def exp(a: float) -> float:
        return math.exp(a)

    @staticmethod
    def log(a: float) -> float:
        return math.log(a)

    @staticmethod
    def pow(a: float, b: float) -> float:
        return a ** b

    @staticmethod
    def sqrt(a: float) -> float:
        return math.sqrt(a)

    @staticmethod
    def sin(angle: float) -> float:
        return math.sin(angle)

    @staticmethod
    def cos(angle: float) -> float:
        return math.cos(angle)

    @staticmethod
    def tan(angle: float) -> float:
        return math.tan(angle)

    @staticmethod
    def atan2(a: float, b: float) -> float:
        return math.atan2(a, b)

    @staticmethod
    def random() -> float:
        import random
        return random.random()

    @staticmethod
    def isNaN(v: float) -> bool:
        return math.isnan(v)

    @staticmethod
    def nanToZero(value: float) -> float:
        return 0.0 if math.isnan(value) else value


# ═══════════════════════════════════════════════════════════════
# Pattern (re)
# ═══════════════════════════════════════════════════════════════

class Pattern(Stub):
    """Pattern — 正则表达式模式"""

    CASE_INSENSITIVE = 2
    MULTILINE = 8
    DOTALL = 32
    UNICODE_CASE = 64
    CANON_EQ = 128
    UNIX_LINES = 1
    LITERAL = 16
    COMMENTS = 4

    def __init__(self, pattern: str, flags: int = 0):
        super().__init__()
        self._pattern_str = pattern
        self._flags = flags
        re_flags = 0
        if flags & self.CASE_INSENSITIVE:
            re_flags |= _re.IGNORECASE
        if flags & self.MULTILINE:
            re_flags |= _re.MULTILINE
        if flags & self.DOTALL:
            re_flags |= _re.DOTALL
        if flags & self.UNICODE_CASE:
            re_flags |= _re.UNICODE
        if flags & self.UNIX_LINES:
            pass  # no re equivalent
        self._compiled = _re.compile(pattern, re_flags)

    @staticmethod
    def compile(pattern: str, flags: int = 0) -> "Pattern":
        return Pattern(pattern, flags)

    def matcher(self, input_str: str) -> "Matcher":
        return Matcher(self._compiled, input_str)

    def split(self, input_str: str, limit: int = 0) -> List[str]:
        if limit < 0:
            return self._compiled.split(input_str, maxsplit=0)
        return self._compiled.split(input_str, maxsplit=limit - 1 if limit > 0 else 0)

    def pattern(self) -> str:
        return self._pattern_str

    def flags(self) -> int:
        return self._flags

    @staticmethod
    def matches(regex: str, input_str: str) -> bool:
        return bool(_re.fullmatch(regex, input_str))

    @staticmethod
    def quote(s: str) -> str:
        return _re.escape(s)

    def toString(self) -> str:
        return self._pattern_str


class Matcher(Stub):
    """Matcher — 正则匹配器"""

    def __init__(self, compiled_pattern: "Pattern", input_str: str):
        super().__init__()
        self._pattern = compiled_pattern
        self._input = input_str
        self._region_start = 0
        self._region_end = len(input_str)
        self._match: Optional[Any] = None

    def matches(self) -> bool:
        self._match = self._pattern.fullmatch(self._input,
                                              self._region_start, self._region_end)
        return self._match is not None

    def find(self, start: int = 0) -> bool:
        self._match = self._pattern.search(self._input, start or self._region_start,
                                           self._region_end)
        return self._match is not None

    def lookingAt(self) -> bool:
        self._match = self._pattern.match(self._input, self._region_start,
                                          self._region_end)
        return self._match is not None

    def group(self, group: int = 0) -> Optional[str]:
        if self._match:
            return self._match.group(group)
        return None

    def groupCount(self) -> int:
        if self._match:
            return len(self._match.groups())
        return 0

    def start(self, group: int = 0) -> int:
        if self._match:
            return self._match.start(group)
        return -1

    def end(self, group: int = 0) -> int:
        if self._match:
            return self._match.end(group)
        return -1

    def replaceAll(self, replacement: str) -> str:
        return self._pattern.sub(replacement, self._input)

    def replaceFirst(self, replacement: str) -> str:
        return self._pattern.sub(replacement, self._input, count=1)

    def region(self, start: int, end: int) -> "Matcher":
        self._region_start = start
        self._region_end = end
        return self

    def regionStart(self) -> int:
        return self._region_start

    def regionEnd(self) -> int:
        return self._region_end

    def reset(self, input_str: Optional[str] = None) -> "Matcher":
        if input_str is not None:
            self._input = input_str
        self._match = None
        return self

    def hitEnd(self) -> bool:
        return False

    def requireEnd(self) -> bool:
        return False

    def usePattern(self, new_pattern: "Pattern") -> "Matcher":
        self._pattern = new_pattern
        return self

    def appendReplacement(self, sb: Any, replacement: str):
        pass

    def appendTail(self, sb: Any):
        pass

    def toString(self) -> str:
        return f"Matcher({self._pattern.pattern()})"


# ═══════════════════════════════════════════════════════════════
# TYPED_VALUE 常量
# ═══════════════════════════════════════════════════════════════

TYPED_VALUE = TypedValue  # 别名


# ═══════════════════════════════════════════════════════════════
# Pair 反向兼容 (android.util.Pair)
# ═══════════════════════════════════════════════════════════════

# Pair 已在上面定义


# ═══════════════════════════════════════════════════════════════
# __all__
# ═══════════════════════════════════════════════════════════════

__all__ = [
    "Log",
    "SparseArray",
    "SparseIntArray",
    "SparseBooleanArray",
    "LruCache",
    "DisplayMetrics",
    "TypedValue",
    "Pair",
    "Size",
    "SizeF",
    "StateSet",
    "MathUtils",
    "Pattern",
    "Matcher",
    "TYPED_VALUE",
]